SunRed/Marlin-Artillery-M600
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Planner singleton class

Browse source
This commit is contained in:
Scott Lahteine 2016-04-27 18:06:32 -07:00
parent 5076d12344
commit 96f51f400f
10 changed files with 587 additions and 499 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
Marlin/Marlin.h
View file

@ -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_known_position[3]; // axis[n].is_known
extern bool axis_homed[3]; // axis[n].is_homed 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) #if ENABLED(DELTA)
#ifndef DELTA_RADIUS_TRIM_TOWER_1 #ifndef DELTA_RADIUS_TRIM_TOWER_1
#define DELTA_RADIUS_TRIM_TOWER_1 0.0 #define DELTA_RADIUS_TRIM_TOWER_1 0.0

192
Marlin/Marlin_main.cpp
View file

@ -149,7 +149,7 @@
* M84 - Disable steppers until next move, * 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. * 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) * 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 * M104 - Set extruder target temp
* M105 - Read current temp * M105 - Read current temp
* M106 - Fan on * M106 - Fan on
@ -540,7 +540,7 @@ static void report_current_position();
if (DEBUGGING(LEVELING)) DEBUG_POS("sync_plan_position_delta", current_position); if (DEBUGGING(LEVELING)) DEBUG_POS("sync_plan_position_delta", current_position);
#endif #endif
calculate_delta(current_position); 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 #endif
@ -817,7 +817,6 @@ void setup() {
lcd_init(); lcd_init();
tp_init(); // Initialize temperature loop tp_init(); // Initialize temperature loop
plan_init(); // Initialize planner;
#if ENABLED(DELTA) || ENABLED(SCARA) #if ENABLED(DELTA) || ENABLED(SCARA)
// Vital to init kinematic equivalent for X0 Y0 Z0 // Vital to init kinematic equivalent for X0 Y0 Z0
@ -1405,17 +1404,17 @@ inline void set_homing_bump_feedrate(AxisEnum axis) {
// (or from wherever it has been told it is located). // (or from wherever it has been told it is located).
// //
inline void line_to_current_position() { 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) { 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 // line_to_destination
// Move the planner, not necessarily synced with current_position // Move the planner, not necessarily synced with current_position
// //
inline void line_to_destination(float mm_m) { 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() { inline void line_to_destination() {
line_to_destination(feedrate); line_to_destination(feedrate);
@ -1430,9 +1429,9 @@ inline void sync_plan_position() {
#if ENABLED(DEBUG_LEVELING_FEATURE) #if ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) DEBUG_POS("sync_plan_position", current_position); if (DEBUGGING(LEVELING)) DEBUG_POS("sync_plan_position", current_position);
#endif #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_current_to_destination() { memcpy(current_position, destination, sizeof(current_position)); }
inline void set_destination_to_current() { memcpy(destination, current_position, sizeof(destination)); } inline void set_destination_to_current() { memcpy(destination, current_position, sizeof(destination)); }
@ -1459,7 +1458,7 @@ static void setup_for_endstop_move() {
#endif #endif
refresh_cmd_timeout(); refresh_cmd_timeout();
calculate_delta(destination); 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(); set_current_to_destination();
} }
#endif #endif
@ -1470,21 +1469,21 @@ static void setup_for_endstop_move() {
static void set_bed_level_equation_lsq(double* plane_equation_coefficients) { 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) #if ENABLED(DEBUG_LEVELING_FEATURE)
plan_bed_level_matrix.set_to_identity(); planner.bed_level_matrix.set_to_identity();
if (DEBUGGING(LEVELING)) { 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", uncorrected_position);
DEBUG_POS(">>> set_bed_level_equation_lsq", current_position); DEBUG_POS(">>> set_bed_level_equation_lsq", current_position);
} }
#endif #endif
vector_3 planeNormal = vector_3(-plane_equation_coefficients[0], -plane_equation_coefficients[1], 1); 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[X_AXIS] = corrected_position.x;
current_position[Y_AXIS] = corrected_position.y; current_position[Y_AXIS] = corrected_position.y;
current_position[Z_AXIS] = corrected_position.z; current_position[Z_AXIS] = corrected_position.z;
@ -1502,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) { 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 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); vector_3 pt2 = vector_3(ABL_PROBE_PT_2_X, ABL_PROBE_PT_2_Y, z_at_pt_2);
@ -1515,9 +1514,9 @@ static void setup_for_endstop_move() {
planeNormal.z = -planeNormal.z; 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 ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
@ -1568,7 +1567,7 @@ static void setup_for_endstop_move() {
* is not where we said to go. * is not where we said to go.
*/ */
long stop_steps = stepper.position(Z_AXIS); long stop_steps = stepper.position(Z_AXIS);
float mm = start_z - float(start_steps - stop_steps) / axis_steps_per_unit[Z_AXIS]; float mm = start_z - float(start_steps - stop_steps) / planner.axis_steps_per_unit[Z_AXIS];
current_position[Z_AXIS] = mm; current_position[Z_AXIS] = mm;
#if ENABLED(DEBUG_LEVELING_FEATURE) #if ENABLED(DEBUG_LEVELING_FEATURE)
@ -1579,7 +1578,7 @@ static void setup_for_endstop_move() {
#else // !DELTA #else // !DELTA
plan_bed_level_matrix.set_to_identity(); planner.bed_level_matrix.set_to_identity();
feedrate = homing_feedrate[Z_AXIS]; feedrate = homing_feedrate[Z_AXIS];
// Move down until the Z probe (or endstop?) is triggered // Move down until the Z probe (or endstop?) is triggered
@ -1589,7 +1588,7 @@ static void setup_for_endstop_move() {
// Tell the planner where we ended up - Get this from the stepper handler // Tell the planner where we ended up - Get this from the stepper handler
zPosition = stepper.get_axis_position_mm(Z_AXIS); zPosition = stepper.get_axis_position_mm(Z_AXIS);
plan_set_position( planner.set_position(
current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[X_AXIS], current_position[Y_AXIS], zPosition,
current_position[E_AXIS] current_position[E_AXIS]
); );
@ -2552,7 +2551,7 @@ inline void gcode_G28() {
// For auto bed leveling, clear the level matrix // For auto bed leveling, clear the level matrix
#if ENABLED(AUTO_BED_LEVELING_FEATURE) #if ENABLED(AUTO_BED_LEVELING_FEATURE)
plan_bed_level_matrix.set_to_identity(); planner.bed_level_matrix.set_to_identity();
#if ENABLED(DELTA) #if ENABLED(DELTA)
reset_bed_level(); reset_bed_level();
#endif #endif
@ -2630,7 +2629,7 @@ inline void gcode_G28() {
// Raise Z before homing any other axes and z is not already high enough (never lower z) // 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) { if (current_position[Z_AXIS] <= MIN_Z_HEIGHT_FOR_HOMING) {
destination[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 ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
SERIAL_ECHOPAIR("Raise Z (before homing) to ", (MIN_Z_HEIGHT_FOR_HOMING)); SERIAL_ECHOPAIR("Raise Z (before homing) to ", (MIN_Z_HEIGHT_FOR_HOMING));
@ -3201,22 +3200,22 @@ inline void gcode_G28() {
#if ENABLED(DEBUG_LEVELING_FEATURE) && DISABLED(DELTA) #if ENABLED(DEBUG_LEVELING_FEATURE) && DISABLED(DELTA)
if (DEBUGGING(LEVELING)) { 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", corrected_position);
DEBUG_POS("BEFORE matrix.set_to_identity", current_position); DEBUG_POS("BEFORE matrix.set_to_identity", current_position);
} }
#endif #endif
// make sure the bed_level_rotation_matrix is identity or the planner will get it wrong // 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) #if ENABLED(DELTA)
reset_bed_level(); reset_bed_level();
#else //!DELTA #else //!DELTA
//vector_3 corrected_position = plan_get_position(); //vector_3 corrected_position = planner.adjusted_position();
//corrected_position.debug("position before G29"); //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"); //uncorrected_position.debug("position during G29");
current_position[X_AXIS] = uncorrected_position.x; current_position[X_AXIS] = uncorrected_position.x;
current_position[Y_AXIS] = uncorrected_position.y; current_position[Y_AXIS] = uncorrected_position.y;
@ -3415,7 +3414,7 @@ inline void gcode_G28() {
y_tmp = eqnAMatrix[ind + 1 * abl2], y_tmp = eqnAMatrix[ind + 1 * abl2],
z_tmp = 0; 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); NOMORE(min_diff, eqnBVector[ind] - z_tmp);
@ -3438,7 +3437,7 @@ inline void gcode_G28() {
y_tmp = eqnAMatrix[ind + 1 * abl2], y_tmp = eqnAMatrix[ind + 1 * abl2],
z_tmp = 0; 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; float diff = eqnBVector[ind] - z_tmp - min_diff;
if (diff >= 0.0) if (diff >= 0.0)
@ -3497,7 +3496,7 @@ inline void gcode_G28() {
#endif #endif
#else // !DELTA #else // !DELTA
if (verbose_level > 0) 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) { if (!dryrun) {
/** /**
@ -3508,7 +3507,7 @@ inline void gcode_G28() {
float x_tmp = current_position[X_AXIS] + X_PROBE_OFFSET_FROM_EXTRUDER, float x_tmp = current_position[X_AXIS] + X_PROBE_OFFSET_FROM_EXTRUDER,
y_tmp = current_position[Y_AXIS] + Y_PROBE_OFFSET_FROM_EXTRUDER, y_tmp = current_position[Y_AXIS] + Y_PROBE_OFFSET_FROM_EXTRUDER,
z_tmp = current_position[Z_AXIS], z_tmp = current_position[Z_AXIS],
real_z = stepper.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 ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
@ -3520,13 +3519,13 @@ inline void gcode_G28() {
#endif #endif
// Apply the correction sending the Z probe offset // 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. * Get the current Z position and send it to the planner.
* *
* >> (z_tmp - real_z) : The rotated current Z minus the uncorrected Z * >> (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 * >> zprobe_zoffset : Z distance from nozzle to Z probe
* (set by default, M851, EEPROM, or Menu) * (set by default, M851, EEPROM, or Menu)
@ -4065,7 +4064,7 @@ inline void gcode_M42() {
reset_bed_level(); reset_bed_level();
#else #else
// we don't do bed level correction in M48 because we want the raw data when we probe // 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 #endif
if (Z_start_location < Z_RAISE_BEFORE_PROBING * 2.0) if (Z_start_location < Z_RAISE_BEFORE_PROBING * 2.0)
@ -4454,10 +4453,7 @@ inline void gcode_M109() {
} }
#if ENABLED(AUTOTEMP) #if ENABLED(AUTOTEMP)
autotemp_enabled = code_seen('F'); planner.autotemp_M109();
if (autotemp_enabled) autotemp_factor = code_value();
if (code_seen('S')) autotemp_min = code_value();
if (code_seen('B')) autotemp_max = code_value();
#endif #endif
#if TEMP_RESIDENCY_TIME > 0 #if TEMP_RESIDENCY_TIME > 0
@ -4897,15 +4893,15 @@ inline void gcode_M92() {
if (i == E_AXIS) { if (i == E_AXIS) {
float value = code_value(); float value = code_value();
if (value < 20.0) { if (value < 20.0) {
float factor = axis_steps_per_unit[i] / value; // increase e constants if M92 E14 is given for netfab. float factor = planner.axis_steps_per_unit[i] / value; // increase e constants if M92 E14 is given for netfab.
max_e_jerk *= factor; planner.max_e_jerk *= factor;
max_feedrate[i] *= factor; planner.max_feedrate[i] *= factor;
axis_steps_per_sqr_second[i] *= factor; planner.axis_steps_per_sqr_second[i] *= factor;
} }
axis_steps_per_unit[i] = value; planner.axis_steps_per_unit[i] = value;
} }
else { else {
axis_steps_per_unit[i] = code_value(); planner.axis_steps_per_unit[i] = code_value();
} }
} }
} }
@ -4940,9 +4936,9 @@ static void report_current_position() {
SERIAL_EOL; SERIAL_EOL;
SERIAL_PROTOCOLPGM("SCARA step Cal - Theta:"); 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_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; SERIAL_EOL; SERIAL_EOL;
#endif #endif
} }
@ -5083,17 +5079,17 @@ inline void gcode_M200() {
inline void gcode_M201() { inline void gcode_M201() {
for (int8_t i = 0; i < NUM_AXIS; i++) { for (int8_t i = 0; i < NUM_AXIS; i++) {
if (code_seen(axis_codes[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) // 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 #if 0 // Not used for Sprinter/grbl gen6
inline void gcode_M202() { inline void gcode_M202() {
for (int8_t i = 0; i < NUM_AXIS; i++) { 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 #endif
@ -5105,7 +5101,7 @@ inline void gcode_M201() {
inline void gcode_M203() { inline void gcode_M203() {
for (int8_t i = 0; i < NUM_AXIS; i++) { for (int8_t i = 0; i < NUM_AXIS; i++) {
if (code_seen(axis_codes[i])) { if (code_seen(axis_codes[i])) {
max_feedrate[i] = code_value(); planner.max_feedrate[i] = code_value();
} }
} }
} }
@ -5121,23 +5117,23 @@ inline void gcode_M203() {
*/ */
inline void gcode_M204() { inline void gcode_M204() {
if (code_seen('S')) { // Kept for legacy compatibility. Should NOT BE USED for new developments. if (code_seen('S')) { // Kept for legacy compatibility. Should NOT BE USED for new developments.
travel_acceleration = acceleration = code_value(); planner.travel_acceleration = planner.acceleration = code_value();
SERIAL_ECHOPAIR("Setting Print and Travel Acceleration: ", acceleration); SERIAL_ECHOPAIR("Setting Print and Travel Acceleration: ", planner.acceleration);
SERIAL_EOL; SERIAL_EOL;
} }
if (code_seen('P')) { if (code_seen('P')) {
acceleration = code_value(); planner.acceleration = code_value();
SERIAL_ECHOPAIR("Setting Print Acceleration: ", acceleration); SERIAL_ECHOPAIR("Setting Print Acceleration: ", planner.acceleration);
SERIAL_EOL; SERIAL_EOL;
} }
if (code_seen('R')) { if (code_seen('R')) {
retract_acceleration = code_value(); planner.retract_acceleration = code_value();
SERIAL_ECHOPAIR("Setting Retract Acceleration: ", retract_acceleration); SERIAL_ECHOPAIR("Setting Retract Acceleration: ", planner.retract_acceleration);
SERIAL_EOL; SERIAL_EOL;
} }
if (code_seen('T')) { if (code_seen('T')) {
travel_acceleration = code_value(); planner.travel_acceleration = code_value();
SERIAL_ECHOPAIR("Setting Travel Acceleration: ", travel_acceleration); SERIAL_ECHOPAIR("Setting Travel Acceleration: ", planner.travel_acceleration);
SERIAL_EOL; SERIAL_EOL;
} }
} }
@ -5153,12 +5149,12 @@ inline void gcode_M204() {
* E = Max E Jerk (mm/s/s) * E = Max E Jerk (mm/s/s)
*/ */
inline void gcode_M205() { inline void gcode_M205() {
if (code_seen('S')) minimumfeedrate = code_value(); if (code_seen('S')) planner.min_feedrate = code_value();
if (code_seen('T')) mintravelfeedrate = code_value(); if (code_seen('T')) planner.min_travel_feedrate = code_value();
if (code_seen('B')) minsegmenttime = code_value(); if (code_seen('B')) planner.min_segment_time = code_value();
if (code_seen('X')) max_xy_jerk = code_value(); if (code_seen('X')) planner.max_xy_jerk = code_value();
if (code_seen('Z')) max_z_jerk = code_value(); if (code_seen('Z')) planner.max_z_jerk = code_value();
if (code_seen('E')) max_e_jerk = code_value(); if (code_seen('E')) planner.max_e_jerk = code_value();
} }
/** /**
@ -6004,7 +6000,7 @@ inline void gcode_M503() {
#if ENABLED(DELTA) #if ENABLED(DELTA)
#define RUNPLAN calculate_delta(destination); \ #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 #else
#define RUNPLAN line_to_destination(); #define RUNPLAN line_to_destination();
#endif #endif
@ -6097,8 +6093,8 @@ inline void gcode_M503() {
#if ENABLED(DELTA) #if ENABLED(DELTA)
// Move XYZ to starting position, then E // Move XYZ to starting position, then E
calculate_delta(lastpos); calculate_delta(lastpos);
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);
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], lastpos[E_AXIS], fr60, active_extruder);
#else #else
// Move XY to starting position, then Z, then E // Move XY to starting position, then Z, then E
destination[X_AXIS] = lastpos[X_AXIS]; destination[X_AXIS] = lastpos[X_AXIS];
@ -6292,7 +6288,7 @@ inline void gcode_T(uint8_t tmp_extruder) {
#ifdef XY_TRAVEL_SPEED #ifdef XY_TRAVEL_SPEED
feedrate = XY_TRAVEL_SPEED; feedrate = XY_TRAVEL_SPEED;
#else #else
feedrate = min(max_feedrate[X_AXIS], max_feedrate[Y_AXIS]); feedrate = min(planner.max_feedrate[X_AXIS], planner.max_feedrate[Y_AXIS]);
#endif #endif
} }
@ -6304,12 +6300,12 @@ inline void gcode_T(uint8_t tmp_extruder) {
if (dual_x_carriage_mode == DXC_AUTO_PARK_MODE && IsRunning() && if (dual_x_carriage_mode == DXC_AUTO_PARK_MODE && IsRunning() &&
(delayed_move_time || current_position[X_AXIS] != x_home_pos(active_extruder))) { (delayed_move_time || current_position[X_AXIS] != x_home_pos(active_extruder))) {
// Park old head: 1) raise 2) move to park position 3) lower // 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, planner.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); current_position[E_AXIS], planner.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, planner.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); current_position[E_AXIS], planner.max_feedrate[X_AXIS], active_extruder);
plan_buffer_line(x_home_pos(active_extruder), current_position[Y_AXIS], current_position[Z_AXIS], planner.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); current_position[E_AXIS], planner.max_feedrate[Z_AXIS], active_extruder);
stepper.synchronize(); stepper.synchronize();
} }
@ -7186,9 +7182,9 @@ void clamp_to_software_endstops(float target[3]) {
#if ENABLED(MESH_BED_LEVELING) #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 // 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) { 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(); set_current_to_destination();
return; return;
} }
@ -7202,7 +7198,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); iy = min(iy, MESH_NUM_Y_POINTS - 2);
if (pix == ix && piy == iy) { if (pix == ix && piy == iy) {
// Start and end on same mesh square // 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(); set_current_to_destination();
return; return;
} }
@ -7241,7 +7237,7 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_
} }
else { else {
// Already split on a border // 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(); set_current_to_destination();
return; return;
} }
@ -7250,12 +7246,12 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_
destination[Y_AXIS] = ny; destination[Y_AXIS] = ny;
destination[Z_AXIS] = nz; destination[Z_AXIS] = nz;
destination[E_AXIS] = ne; 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[X_AXIS] = x;
destination[Y_AXIS] = y; destination[Y_AXIS] = y;
destination[Z_AXIS] = z; destination[Z_AXIS] = z;
destination[E_AXIS] = e; 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 #endif // MESH_BED_LEVELING
@ -7314,7 +7310,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", target);
//DEBUG_POS("prepare_move_delta", delta); //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; return true;
} }
@ -7331,9 +7327,9 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_
if (active_extruder_parked) { if (active_extruder_parked) {
if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && active_extruder == 0) { if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && active_extruder == 0) {
// move duplicate extruder into correct duplication position. // 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]); planner.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, planner.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); current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], planner.max_feedrate[X_AXIS], 1);
sync_plan_position(); sync_plan_position();
stepper.synchronize(); stepper.synchronize();
extruder_duplication_enabled = true; extruder_duplication_enabled = true;
@ -7353,9 +7349,9 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_
} }
delayed_move_time = 0; delayed_move_time = 0;
// unpark extruder: 1) raise, 2) move into starting XY position, 3) lower // 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); 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);
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); 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);
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(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; active_extruder_parked = false;
} }
} }
@ -7373,7 +7369,7 @@ void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_
} }
else { else {
#if ENABLED(MESH_BED_LEVELING) #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; return false;
#else #else
line_to_destination(feedrate * feedrate_multiplier / 100.0); line_to_destination(feedrate * feedrate_multiplier / 100.0);
@ -7387,7 +7383,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 * 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.) * smaller moves into the planner for DELTA or SCARA.)
*/ */
void prepare_move() { void prepare_move() {
@ -7531,9 +7527,9 @@ void plan_arc(
#if ENABLED(AUTO_BED_LEVELING_FEATURE) #if ENABLED(AUTO_BED_LEVELING_FEATURE)
adjust_delta(arc_target); adjust_delta(arc_target);
#endif #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 #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 #endif
} }
@ -7543,9 +7539,9 @@ void plan_arc(
#if ENABLED(AUTO_BED_LEVELING_FEATURE) #if ENABLED(AUTO_BED_LEVELING_FEATURE)
adjust_delta(target); adjust_delta(target);
#endif #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 #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 #endif
// As far as the parser is concerned, the position is now == target. In reality the // As far as the parser is concerned, the position is now == target. In reality the
@ -7762,7 +7758,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 (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) 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) #if ENABLED(DISABLE_INACTIVE_X)
disable_x(); disable_x();
#endif #endif
@ -7855,12 +7851,12 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
#endif #endif
} }
float oldepos = current_position[E_AXIS], oldedes = destination[E_AXIS]; float oldepos = current_position[E_AXIS], oldedes = destination[E_AXIS];
plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], planner.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], destination[E_AXIS] + (EXTRUDER_RUNOUT_EXTRUDE) * (EXTRUDER_RUNOUT_ESTEPS) / planner.axis_steps_per_unit[E_AXIS],
(EXTRUDER_RUNOUT_SPEED) / 60. * (EXTRUDER_RUNOUT_ESTEPS) / axis_steps_per_unit[E_AXIS], active_extruder); (EXTRUDER_RUNOUT_SPEED) / 60. * (EXTRUDER_RUNOUT_ESTEPS) / planner.axis_steps_per_unit[E_AXIS], active_extruder);
current_position[E_AXIS] = oldepos; current_position[E_AXIS] = oldepos;
destination[E_AXIS] = oldedes; destination[E_AXIS] = oldedes;
plan_set_e_position(oldepos); planner.set_e_position(oldepos);
previous_cmd_ms = ms; // refresh_cmd_timeout() previous_cmd_ms = ms; // refresh_cmd_timeout()
stepper.synchronize(); stepper.synchronize();
switch (active_extruder) { switch (active_extruder) {
@ -7900,7 +7896,7 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
handle_status_leds(); handle_status_leds();
#endif #endif
check_axes_activity(); planner.check_axes_activity();
} }
void kill(const char* lcd_msg) { void kill(const char* lcd_msg) {

142
Marlin/configuration_store.cpp
View file

@ -43,18 +43,18 @@
* *
* 100 Version (char x4) * 100 Version (char x4)
* *
* 104 M92 XYZE axis_steps_per_unit (float x4) * 104 M92 XYZE planner.axis_steps_per_unit (float x4)
* 120 M203 XYZE max_feedrate (float x4) * 120 M203 XYZE planner.max_feedrate (float x4)
* 136 M201 XYZE max_acceleration_units_per_sq_second (uint32_t x4) * 136 M201 XYZE planner.max_acceleration_units_per_sq_second (uint32_t x4)
* 152 M204 P acceleration (float) * 152 M204 P planner.acceleration (float)
* 156 M204 R retract_acceleration (float) * 156 M204 R planner.retract_acceleration (float)
* 160 M204 T travel_acceleration (float) * 160 M204 T planner.travel_acceleration (float)
* 164 M205 S minimumfeedrate (float) * 164 M205 S planner.min_feedrate (float)
* 168 M205 T mintravelfeedrate (float) * 168 M205 T planner.min_travel_feedrate (float)
* 172 M205 B minsegmenttime (ulong) * 172 M205 B planner.min_segment_time (ulong)
* 176 M205 X max_xy_jerk (float) * 176 M205 X planner.max_xy_jerk (float)
* 180 M205 Z max_z_jerk (float) * 180 M205 Z planner.max_z_jerk (float)
* 184 M205 E max_e_jerk (float) * 184 M205 E planner.max_e_jerk (float)
* 188 M206 XYZ home_offset (float x3) * 188 M206 XYZ home_offset (float x3)
* *
* Mesh bed leveling: * Mesh bed leveling:
@ -173,18 +173,18 @@ void Config_StoreSettings() {
char ver[4] = "000"; char ver[4] = "000";
int i = EEPROM_OFFSET; int i = EEPROM_OFFSET;
EEPROM_WRITE_VAR(i, ver); // invalidate data first EEPROM_WRITE_VAR(i, ver); // invalidate data first
EEPROM_WRITE_VAR(i, axis_steps_per_unit); EEPROM_WRITE_VAR(i, planner.axis_steps_per_unit);
EEPROM_WRITE_VAR(i, max_feedrate); EEPROM_WRITE_VAR(i, planner.max_feedrate);
EEPROM_WRITE_VAR(i, max_acceleration_units_per_sq_second); EEPROM_WRITE_VAR(i, planner.max_acceleration_units_per_sq_second);
EEPROM_WRITE_VAR(i, acceleration); EEPROM_WRITE_VAR(i, planner.acceleration);
EEPROM_WRITE_VAR(i, retract_acceleration); EEPROM_WRITE_VAR(i, planner.retract_acceleration);
EEPROM_WRITE_VAR(i, travel_acceleration); EEPROM_WRITE_VAR(i, planner.travel_acceleration);
EEPROM_WRITE_VAR(i, minimumfeedrate); EEPROM_WRITE_VAR(i, planner.min_feedrate);
EEPROM_WRITE_VAR(i, mintravelfeedrate); EEPROM_WRITE_VAR(i, planner.min_travel_feedrate);
EEPROM_WRITE_VAR(i, minsegmenttime); EEPROM_WRITE_VAR(i, planner.min_segment_time);
EEPROM_WRITE_VAR(i, max_xy_jerk); EEPROM_WRITE_VAR(i, planner.max_xy_jerk);
EEPROM_WRITE_VAR(i, max_z_jerk); EEPROM_WRITE_VAR(i, planner.max_z_jerk);
EEPROM_WRITE_VAR(i, max_e_jerk); EEPROM_WRITE_VAR(i, planner.max_e_jerk);
EEPROM_WRITE_VAR(i, home_offset); EEPROM_WRITE_VAR(i, home_offset);
uint8_t mesh_num_x = 3; uint8_t mesh_num_x = 3;
@ -351,22 +351,22 @@ void Config_RetrieveSettings() {
float dummy = 0; float dummy = 0;
// version number match // version number match
EEPROM_READ_VAR(i, axis_steps_per_unit); EEPROM_READ_VAR(i, planner.axis_steps_per_unit);
EEPROM_READ_VAR(i, max_feedrate); EEPROM_READ_VAR(i, planner.max_feedrate);
EEPROM_READ_VAR(i, max_acceleration_units_per_sq_second); 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) // steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner)
reset_acceleration_rates(); planner.reset_acceleration_rates();
EEPROM_READ_VAR(i, acceleration); EEPROM_READ_VAR(i, planner.acceleration);
EEPROM_READ_VAR(i, retract_acceleration); EEPROM_READ_VAR(i, planner.retract_acceleration);
EEPROM_READ_VAR(i, travel_acceleration); EEPROM_READ_VAR(i, planner.travel_acceleration);
EEPROM_READ_VAR(i, minimumfeedrate); EEPROM_READ_VAR(i, planner.min_feedrate);
EEPROM_READ_VAR(i, mintravelfeedrate); EEPROM_READ_VAR(i, planner.min_travel_feedrate);
EEPROM_READ_VAR(i, minsegmenttime); EEPROM_READ_VAR(i, planner.min_segment_time);
EEPROM_READ_VAR(i, max_xy_jerk); EEPROM_READ_VAR(i, planner.max_xy_jerk);
EEPROM_READ_VAR(i, max_z_jerk); EEPROM_READ_VAR(i, planner.max_z_jerk);
EEPROM_READ_VAR(i, max_e_jerk); EEPROM_READ_VAR(i, planner.max_e_jerk);
EEPROM_READ_VAR(i, home_offset); EEPROM_READ_VAR(i, home_offset);
uint8_t dummy_uint8 = 0, mesh_num_x = 0, mesh_num_y = 0; 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; float tmp2[] = DEFAULT_MAX_FEEDRATE;
long tmp3[] = DEFAULT_MAX_ACCELERATION; long tmp3[] = DEFAULT_MAX_ACCELERATION;
for (uint8_t i = 0; i < NUM_AXIS; i++) { for (uint8_t i = 0; i < NUM_AXIS; i++) {
axis_steps_per_unit[i] = tmp1[i]; planner.axis_steps_per_unit[i] = tmp1[i];
max_feedrate[i] = tmp2[i]; planner.max_feedrate[i] = tmp2[i];
max_acceleration_units_per_sq_second[i] = tmp3[i]; planner.max_acceleration_units_per_sq_second[i] = tmp3[i];
#if ENABLED(SCARA) #if ENABLED(SCARA)
if (i < COUNT(axis_scaling)) if (i < COUNT(axis_scaling))
axis_scaling[i] = 1; 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 // steps per sq second need to be updated to agree with the units per sq second
reset_acceleration_rates(); planner.reset_acceleration_rates();
acceleration = DEFAULT_ACCELERATION; planner.acceleration = DEFAULT_ACCELERATION;
retract_acceleration = DEFAULT_RETRACT_ACCELERATION; planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
travel_acceleration = DEFAULT_TRAVEL_ACCELERATION; planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
minimumfeedrate = DEFAULT_MINIMUMFEEDRATE; planner.min_feedrate = DEFAULT_MINIMUMFEEDRATE;
minsegmenttime = DEFAULT_MINSEGMENTTIME; planner.min_segment_time = DEFAULT_MINSEGMENTTIME;
mintravelfeedrate = DEFAULT_MINTRAVELFEEDRATE; planner.min_travel_feedrate = DEFAULT_MINTRAVELFEEDRATE;
max_xy_jerk = DEFAULT_XYJERK; planner.max_xy_jerk = DEFAULT_XYJERK;
max_z_jerk = DEFAULT_ZJERK; planner.max_z_jerk = DEFAULT_ZJERK;
max_e_jerk = DEFAULT_EJERK; planner.max_e_jerk = DEFAULT_EJERK;
home_offset[X_AXIS] = home_offset[Y_AXIS] = home_offset[Z_AXIS] = 0; home_offset[X_AXIS] = home_offset[Y_AXIS] = home_offset[Z_AXIS] = 0;
#if ENABLED(MESH_BED_LEVELING) #if ENABLED(MESH_BED_LEVELING)
@ -653,10 +653,10 @@ void Config_PrintSettings(bool forReplay) {
SERIAL_ECHOLNPGM("Steps per unit:"); SERIAL_ECHOLNPGM("Steps per unit:");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOPAIR(" M92 X", axis_steps_per_unit[X_AXIS]); SERIAL_ECHOPAIR(" M92 X", planner.axis_steps_per_unit[X_AXIS]);
SERIAL_ECHOPAIR(" Y", axis_steps_per_unit[Y_AXIS]); SERIAL_ECHOPAIR(" Y", planner.axis_steps_per_unit[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", axis_steps_per_unit[Z_AXIS]); SERIAL_ECHOPAIR(" Z", planner.axis_steps_per_unit[Z_AXIS]);
SERIAL_ECHOPAIR(" E", axis_steps_per_unit[E_AXIS]); SERIAL_ECHOPAIR(" E", planner.axis_steps_per_unit[E_AXIS]);
SERIAL_EOL; SERIAL_EOL;
CONFIG_ECHO_START; CONFIG_ECHO_START;
@ -677,10 +677,10 @@ void Config_PrintSettings(bool forReplay) {
SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):"); SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOPAIR(" M203 X", max_feedrate[X_AXIS]); SERIAL_ECHOPAIR(" M203 X", planner.max_feedrate[X_AXIS]);
SERIAL_ECHOPAIR(" Y", max_feedrate[Y_AXIS]); SERIAL_ECHOPAIR(" Y", planner.max_feedrate[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", max_feedrate[Z_AXIS]); SERIAL_ECHOPAIR(" Z", planner.max_feedrate[Z_AXIS]);
SERIAL_ECHOPAIR(" E", max_feedrate[E_AXIS]); SERIAL_ECHOPAIR(" E", planner.max_feedrate[E_AXIS]);
SERIAL_EOL; SERIAL_EOL;
CONFIG_ECHO_START; CONFIG_ECHO_START;
@ -688,19 +688,19 @@ void Config_PrintSettings(bool forReplay) {
SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):"); SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOPAIR(" M201 X", max_acceleration_units_per_sq_second[X_AXIS]); SERIAL_ECHOPAIR(" M201 X", planner.max_acceleration_units_per_sq_second[X_AXIS]);
SERIAL_ECHOPAIR(" Y", max_acceleration_units_per_sq_second[Y_AXIS]); SERIAL_ECHOPAIR(" Y", planner.max_acceleration_units_per_sq_second[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", max_acceleration_units_per_sq_second[Z_AXIS]); SERIAL_ECHOPAIR(" Z", planner.max_acceleration_units_per_sq_second[Z_AXIS]);
SERIAL_ECHOPAIR(" E", max_acceleration_units_per_sq_second[E_AXIS]); SERIAL_ECHOPAIR(" E", planner.max_acceleration_units_per_sq_second[E_AXIS]);
SERIAL_EOL; SERIAL_EOL;
CONFIG_ECHO_START; CONFIG_ECHO_START;
if (!forReplay) { if (!forReplay) {
SERIAL_ECHOLNPGM("Accelerations: P=printing, R=retract and T=travel"); SERIAL_ECHOLNPGM("Accelerations: P=printing, R=retract and T=travel");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOPAIR(" M204 P", acceleration); SERIAL_ECHOPAIR(" M204 P", planner.acceleration);
SERIAL_ECHOPAIR(" R", retract_acceleration); SERIAL_ECHOPAIR(" R", planner.retract_acceleration);
SERIAL_ECHOPAIR(" T", travel_acceleration); SERIAL_ECHOPAIR(" T", planner.travel_acceleration);
SERIAL_EOL; SERIAL_EOL;
CONFIG_ECHO_START; 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)"); 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; CONFIG_ECHO_START;
} }
SERIAL_ECHOPAIR(" M205 S", minimumfeedrate); SERIAL_ECHOPAIR(" M205 S", planner.min_feedrate);
SERIAL_ECHOPAIR(" T", mintravelfeedrate); SERIAL_ECHOPAIR(" T", planner.min_travel_feedrate);
SERIAL_ECHOPAIR(" B", minsegmenttime); SERIAL_ECHOPAIR(" B", planner.min_segment_time);
SERIAL_ECHOPAIR(" X", max_xy_jerk); SERIAL_ECHOPAIR(" X", planner.max_xy_jerk);
SERIAL_ECHOPAIR(" Z", max_z_jerk); SERIAL_ECHOPAIR(" Z", planner.max_z_jerk);
SERIAL_ECHOPAIR(" E", max_e_jerk); SERIAL_ECHOPAIR(" E", planner.max_e_jerk);
SERIAL_EOL; SERIAL_EOL;
CONFIG_ECHO_START; CONFIG_ECHO_START;

350
Marlin/planner.cpp
View file

@ -81,105 +81,27 @@
#include "mesh_bed_leveling.h" #include "mesh_bed_leveling.h"
#endif #endif
//=========================================================================== Planner planner;
//============================= public variables ============================
//===========================================================================
millis_t minsegmenttime; Planner::Planner() {
float max_feedrate[NUM_AXIS]; // Max speeds in mm per minute #if ENABLED(AUTO_BED_LEVELING_FEATURE)
float axis_steps_per_unit[NUM_AXIS]; bed_level_matrix.set_to_identity();
unsigned long max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software #endif
float minimumfeedrate; init();
float acceleration; // Normal acceleration mm/s^2 DEFAULT ACCELERATION for all printing moves. M204 SXXXX
float retract_acceleration; // Retract acceleration mm/s^2 filament pull-back and push-forward while standing still in the other axes M204 TXXXX
float travel_acceleration; // Travel acceleration mm/s^2 DEFAULT ACCELERATION for all NON printing moves. M204 MXXXX
float max_xy_jerk; // The largest speed change requiring no acceleration
float max_z_jerk;
float max_e_jerk;
float mintravelfeedrate;
unsigned long axis_steps_per_sqr_second[NUM_AXIS];
#if ENABLED(AUTO_BED_LEVELING_FEATURE)
// Transform required to compensate for bed level
matrix_3x3 plan_bed_level_matrix = {
1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0
};
#endif // AUTO_BED_LEVELING_FEATURE
#if ENABLED(AUTOTEMP)
float autotemp_max = 250;
float autotemp_min = 210;
float autotemp_factor = 0.1;
bool autotemp_enabled = false;
#endif
#if ENABLED(FAN_SOFT_PWM)
extern unsigned char fanSpeedSoftPwm[FAN_COUNT];
#endif
//===========================================================================
//============ semi-private variables, used in inline functions =============
//===========================================================================
block_t block_buffer[BLOCK_BUFFER_SIZE]; // A ring buffer for motion instfructions
volatile unsigned char block_buffer_head; // Index of the next block to be pushed
volatile unsigned char block_buffer_tail; // Index of the block to process now
//===========================================================================
//============================ private variables ============================
//===========================================================================
// The current position of the tool in absolute steps
long position[NUM_AXIS]; // Rescaled from extern when axis_steps_per_unit are changed by gcode
static float previous_speed[NUM_AXIS]; // Speed of previous path line segment
static float previous_nominal_speed; // Nominal speed of previous path line segment
uint8_t g_uc_extruder_last_move[EXTRUDERS] = { 0 };
#ifdef XY_FREQUENCY_LIMIT
// Used for the frequency limit
#define MAX_FREQ_TIME (1000000.0/XY_FREQUENCY_LIMIT)
// Old direction bits. Used for speed calculations
static unsigned char old_direction_bits = 0;
// Segment times (in µs). Used for speed calculations
static long axis_segment_time[2][3] = { {MAX_FREQ_TIME + 1, 0, 0}, {MAX_FREQ_TIME + 1, 0, 0} };
#endif
#if ENABLED(DUAL_X_CARRIAGE)
extern bool extruder_duplication_enabled;
#endif
//===========================================================================
//================================ functions ================================
//===========================================================================
// Get the next / previous index of the next block in the ring buffer
// NOTE: Using & here (not %) because BLOCK_BUFFER_SIZE is always a power of 2
FORCE_INLINE int8_t next_block_index(int8_t block_index) { return BLOCK_MOD(block_index + 1); }
FORCE_INLINE int8_t prev_block_index(int8_t block_index) { return BLOCK_MOD(block_index - 1); }
// Calculates the distance (not time) it takes to accelerate from initial_rate to target_rate using the
// given acceleration:
FORCE_INLINE float estimate_acceleration_distance(float initial_rate, float target_rate, float acceleration) {
if (acceleration == 0) return 0; // acceleration was 0, set acceleration distance to 0
return (target_rate * target_rate - initial_rate * initial_rate) / (acceleration * 2);
} }
// This function gives you the point at which you must start braking (at the rate of -acceleration) if void Planner::init() {
// you started at speed initial_rate and accelerated until this point and want to end at the final_rate after block_buffer_head = block_buffer_tail = 0;
// a total travel of distance. This can be used to compute the intersection point between acceleration and memset(position, 0, sizeof(position)); // clear position
// deceleration in the cases where the trapezoid has no plateau (i.e. never reaches maximum speed) for (int i = 0; i < NUM_AXIS; i++) previous_speed[i] = 0.0;
previous_nominal_speed = 0.0;
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);
} }
// Calculates trapezoid parameters so that the entry- and exit-speed is compensated by the provided factors. /**
* Calculate trapezoid parameters, multiplying the entry- and exit-speeds
void calculate_trapezoid_for_block(block_t* block, float entry_factor, float exit_factor) { * 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), unsigned long initial_rate = ceil(block->nominal_rate * entry_factor),
final_rate = ceil(block->nominal_rate * exit_factor); // (steps per second) 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; 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. // "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 // This method will calculate the junction jerk as the euclidean distance between the nominal
// velocities of the respective blocks. // 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. // 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) { void Planner::reverse_pass_kernel(block_t* previous, block_t* current, block_t* next) {
if (!current) return; if (!current) return;
UNUSED(previous); 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. } // 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. * recalculate() needs to go over the current plan twice.
void planner_reverse_pass() { * Once in reverse and once forward. This implements the reverse pass.
uint8_t block_index = block_buffer_head; */
void Planner::reverse_pass() {
//Make a local copy of block_buffer_tail, because the interrupt can alter it if (movesplanned() > 3) {
CRITICAL_SECTION_START;
unsigned char tail = block_buffer_tail;
CRITICAL_SECTION_END
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 }; 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[2] = block[1];
block[1] = block[0]; block[1] = block[0];
block[0] = &block_buffer[block_index]; block[0] = &block_buffer[b];
planner_reverse_pass_kernel(block[0], block[1], block[2]); reverse_pass_kernel(block[0], block[1], block[2]);
} }
} }
} }
// The kernel called by planner_recalculate() when scanning the plan from first to last entry. // 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) { void Planner::forward_pass_kernel(block_t* previous, block_t* current, block_t* next) {
if (!previous) return; if (!previous) return;
UNUSED(next); 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. * recalculate() needs to go over the current plan twice.
void planner_forward_pass() { * Once in reverse and once forward. This implements the forward pass.
uint8_t block_index = block_buffer_tail; */
void Planner::forward_pass() {
block_t* block[3] = { NULL, NULL, NULL }; 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[0] = block[1];
block[1] = block[2]; block[1] = block[2];
block[2] = &block_buffer[block_index]; block[2] = &block_buffer[b];
planner_forward_pass_kernel(block[0], block[1], block[2]); forward_pass_kernel(block[0], block[1], block[2]);
block_index = next_block_index(block_index);
} }
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 * Recalculate the trapezoid speed profiles for all blocks in the plan
// updating the blocks. * according to the entry_factor for each junction. Must be called by
void planner_recalculate_trapezoids() { * recalculate() after updating the blocks.
*/
void Planner::recalculate_trapezoids() {
int8_t block_index = block_buffer_tail; int8_t block_index = block_buffer_tail;
block_t* current; block_t* current;
block_t* next = NULL; block_t* next = NULL;
@ -358,54 +279,52 @@ void planner_recalculate_trapezoids() {
} }
} }
// Recalculates the motion plan according to the following algorithm: /*
// * Recalculate 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: * 1. Go over every block in reverse order...
// a. The junction jerk is within the set limit *
// b. No speed reduction within one block requires faster deceleration than the one, true constant * Calculate a junction speed reduction (block_t.entry_factor) so:
// acceleration. *
// 2. Go over every block in chronological order and dial down junction speed reduction values if * a. The junction jerk is within the set limit, and
// a. The speed increase within one block would require faster acceleration than the one, true *
// constant acceleration. * b. No speed reduction within one block requires faster
// * deceleration 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 * 2. Go over every block in chronological order...
// the set limit. Finally it will: *
// * Dial down junction speed reduction values if:
// 3. Recalculate trapezoids for all blocks. * a. The speed increase within one block would require faster
* acceleration than the one, true constant acceleration.
void planner_recalculate() { *
planner_reverse_pass(); * After that, all blocks will have an entry_factor allowing all speed changes to
planner_forward_pass(); * be performed using only the one, true constant acceleration, and where no junction
planner_recalculate_trapezoids(); * jerk is jerkier than the set limit, Jerky. Finally it will:
} *
* 3. Recalculate "trapezoids" for all blocks.
void plan_init() { */
block_buffer_head = block_buffer_tail = 0; void Planner::recalculate() {
memset(position, 0, sizeof(position)); // clear position reverse_pass();
for (int i = 0; i < NUM_AXIS; i++) previous_speed[i] = 0.0; forward_pass();
previous_nominal_speed = 0.0; recalculate_trapezoids();
} }
#if ENABLED(AUTOTEMP) #if ENABLED(AUTOTEMP)
void getHighESpeed() {
void Planner::getHighESpeed() {
static float oldt = 0; static float oldt = 0;
if (!autotemp_enabled) return; if (!autotemp_enabled) return;
if (degTargetHotend0() + 2 < autotemp_min) return; // probably temperature set to zero. if (degTargetHotend0() + 2 < autotemp_min) return; // probably temperature set to zero.
float high = 0.0; float high = 0.0;
uint8_t block_index = block_buffer_tail; for (uint8_t b = block_buffer_tail; b != block_buffer_head; b = next_block_index(b)) {
block_t* block = &block_buffer[b];
while (block_index != block_buffer_head) {
block_t* block = &block_buffer[block_index];
if (block->steps[X_AXIS] || block->steps[Y_AXIS] || block->steps[Z_AXIS]) { 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; float se = (float)block->steps[E_AXIS] / block->step_event_count * block->nominal_speed; // mm/sec;
NOLESS(high, se); NOLESS(high, se);
} }
block_index = next_block_index(block_index);
} }
float t = autotemp_min + high * autotemp_factor; float t = autotemp_min + high * autotemp_factor;
@ -417,9 +336,13 @@ void plan_init() {
oldt = t; oldt = t;
setTargetHotend0(t); setTargetHotend0(t);
} }
#endif //AUTOTEMP #endif //AUTOTEMP
void check_axes_activity() { /**
* Maintain fans, paste extruder pressure,
*/
void Planner::check_axes_activity() {
unsigned char axis_active[NUM_AXIS] = { 0 }, unsigned char axis_active[NUM_AXIS] = { 0 },
tail_fan_speed[FAN_COUNT]; tail_fan_speed[FAN_COUNT];
@ -432,26 +355,23 @@ void check_axes_activity() {
tail_e_to_p_pressure = baricuda_e_to_p_pressure; tail_e_to_p_pressure = baricuda_e_to_p_pressure;
#endif #endif
block_t* block;
if (blocks_queued()) { if (blocks_queued()) {
uint8_t block_index = block_buffer_tail;
#if FAN_COUNT > 0 #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 #endif
block_t* block;
#if ENABLED(BARICUDA) #if ENABLED(BARICUDA)
block = &block_buffer[block_index]; block = &block_buffer[block_buffer_tail];
tail_valve_pressure = block->valve_pressure; tail_valve_pressure = block->valve_pressure;
tail_e_to_p_pressure = block->e_to_p_pressure; tail_e_to_p_pressure = block->e_to_p_pressure;
#endif #endif
while (block_index != block_buffer_head) { for (uint8_t b = block_buffer_tail; b != block_buffer_head; b = next_block_index(b)) {
block = &block_buffer[block_index]; block = &block_buffer[b];
for (int i = 0; i < NUM_AXIS; i++) if (block->steps[i]) axis_active[i]++; 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) #if ENABLED(DISABLE_X)
@ -549,15 +469,20 @@ void check_axes_activity() {
#endif #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) #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 #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 #endif // AUTO_BED_LEVELING_FEATURE
{ {
// Calculate the buffer head after we push this byte // Calculate the buffer head after we push this byte
@ -570,7 +495,7 @@ float junction_deviation = 0.1;
#if ENABLED(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]); if (mbl.active) z += mbl.get_z(x - home_offset[X_AXIS], y - home_offset[Y_AXIS]);
#elif ENABLED(AUTO_BED_LEVELING_FEATURE) #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 #endif
// The target position of the tool in absolute steps // The target position of the tool in absolute steps
@ -703,7 +628,8 @@ float junction_deviation = 0.1;
// Enable extruder(s) // Enable extruder(s)
if (block->steps[E_AXIS]) { 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++) for (int i = 0; i < EXTRUDERS; i++)
if (g_uc_extruder_last_move[i] > 0) g_uc_extruder_last_move[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 > 2
#endif // EXTRUDERS > 1 #endif // EXTRUDERS > 1
} }
} #else
else { // enable all
enable_e0(); enable_e0();
enable_e1(); enable_e1();
enable_e2(); enable_e2();
enable_e3(); enable_e3();
} #endif
} }
if (block->steps[E_AXIS]) if (block->steps[E_AXIS])
NOLESS(feed_rate, minimumfeedrate); NOLESS(feed_rate, min_feedrate);
else else
NOLESS(feed_rate, mintravelfeedrate); NOLESS(feed_rate, min_travel_feedrate);
/** /**
* This part of the code calculates the total length of the movement. * 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 // segment time im micro seconds
unsigned long segment_time = lround(1000000.0/inverse_second); unsigned long segment_time = lround(1000000.0/inverse_second);
if (mq) { 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. // 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 #ifdef XY_FREQUENCY_LIMIT
segment_time = lround(1000000.0 / inverse_second); segment_time = lround(1000000.0 / inverse_second);
#endif #endif
@ -968,6 +893,9 @@ float junction_deviation = 0.1;
block->acceleration_rate = (long)(acc_st * 16777216.0 / (F_CPU / 8.0)); block->acceleration_rate = (long)(acc_st * 16777216.0 / (F_CPU / 8.0));
#if 0 // Use old jerk for now #if 0 // Use old jerk for now
float junction_deviation = 0.1;
// Compute path unit vector // Compute path unit vector
double unit_vec[3]; double unit_vec[3];
@ -1083,11 +1011,11 @@ float junction_deviation = 0.1;
// Update position // Update position
for (int i = 0; i < NUM_AXIS; i++) position[i] = target[i]; for (int i = 0; i < NUM_AXIS; i++) position[i] = target[i];
planner_recalculate(); recalculate();
stepper.wake_up(); stepper.wake_up();
} // plan_buffer_line() } // buffer_line()
#if ENABLED(AUTO_BED_LEVELING_FEATURE) && DISABLED(DELTA) #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. * On CORE machines XYZ is derived from ABC.
*/ */
vector_3 plan_get_position() { 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)); 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 plan_get position"); //position.debug("in Planner::position");
//plan_bed_level_matrix.debug("in plan_get_position"); //bed_level_matrix.debug("in Planner::position");
matrix_3x3 inverse = matrix_3x3::transpose(plan_bed_level_matrix);
//inverse.debug("in plan_get inverse"); matrix_3x3 inverse = matrix_3x3::transpose(bed_level_matrix);
//inverse.debug("in Planner::inverse");
position.apply_rotation(inverse); position.apply_rotation(inverse);
//position.debug("after rotation"); //position.debug("after rotation");
@ -1117,15 +1047,15 @@ float junction_deviation = 0.1;
* On CORE machines stepper ABC will be translated from the given XYZ. * On CORE machines stepper ABC will be translated from the given XYZ.
*/ */
#if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(MESH_BED_LEVELING) #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 #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 #endif // AUTO_BED_LEVELING_FEATURE || MESH_BED_LEVELING
{ {
#if ENABLED(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]); if (mbl.active) z += mbl.get_z(x - home_offset[X_AXIS], y - home_offset[Y_AXIS]);
#elif ENABLED(AUTO_BED_LEVELING_FEATURE) #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 #endif
long nx = position[X_AXIS] = lround(x * axis_steps_per_unit[X_AXIS]), long nx = position[X_AXIS] = lround(x * axis_steps_per_unit[X_AXIS]),
@ -1138,13 +1068,27 @@ float junction_deviation = 0.1;
for (int i = 0; i < NUM_AXIS; i++) previous_speed[i] = 0.0; 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]); position[E_AXIS] = lround(e * axis_steps_per_unit[E_AXIS]);
stepper.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 // Recalculate the steps/s^2 acceleration rates, based on the mm/s^2
void reset_acceleration_rates() { void Planner::reset_acceleration_rates() {
for (int i = 0; i < NUM_AXIS; i++) 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]; 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

302
Marlin/planner.h
View file

@ -48,17 +48,36 @@
#include "Marlin.h" #include "Marlin.h"
// This struct is used when buffering the setup for each linear movement "nominal" values are as specified in #if ENABLED(AUTO_BED_LEVELING_FEATURE)
// the source g-code and may never actually be reached if acceleration management is active. #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 { typedef struct {
unsigned char active_extruder; // The extruder to move (if E move)
// Fields used by the bresenham algorithm for tracing the line // Fields used by the bresenham algorithm for tracing the line
long steps[NUM_AXIS]; // Step count along each axis long steps[NUM_AXIS]; // Step count along each axis
unsigned long step_event_count; // The number of step events required to complete this block 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 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 decelerate_after; // The index of the step event on which to start decelerating
long acceleration_rate; // The acceleration rate used for acceleration calculation 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 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) #if ENABLED(ADVANCE)
long advance_rate; long advance_rate;
volatile long initial_advance; volatile long initial_advance;
@ -67,7 +86,6 @@ typedef struct {
#endif #endif
// Fields used by the motion planner to manage acceleration // 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 nominal_speed; // The nominal speed for this block in mm/sec
float entry_speed; // Entry speed at previous-current junction 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 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)) #define BLOCK_MOD(n) ((n)&(BLOCK_BUFFER_SIZE-1))
// Initialize the motion plan subsystem class Planner {
void plan_init();
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); }
#if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(MESH_BED_LEVELING)
#if ENABLED(AUTO_BED_LEVELING_FEATURE)
#include "vector_3.h"
// Transform required to compensate for bed level
extern matrix_3x3 plan_bed_level_matrix;
/** /**
* Get the position applying the bed level matrix * A ring buffer of moves described in steps
*/ */
vector_3 plan_get_position(); block_t block_buffer[BLOCK_BUFFER_SIZE];
#endif // AUTO_BED_LEVELING_FEATURE 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
* Add a new linear movement to the buffer. x, y, z are the signed, absolute target position in float axis_steps_per_unit[NUM_AXIS];
* millimeters. Feed rate specifies the (target) speed of the motion. 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
void plan_buffer_line(float x, float y, float z, const float& e, float feed_rate, const uint8_t extruder);
/** millis_t min_segment_time;
* Set the planner positions. Used for G92 instructions. float min_feedrate;
* Multiplies by axis_steps_per_unit[] to set stepper positions. float acceleration; // Normal acceleration mm/s^2 DEFAULT ACCELERATION for all printing moves. M204 SXXXX
* Clears previous speed values. 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
void plan_set_position(float x, float y, float z, const float& e); float max_xy_jerk; // The largest speed change requiring no acceleration
float max_z_jerk;
float max_e_jerk;
float min_travel_feedrate;
#else #if ENABLED(AUTO_BED_LEVELING_FEATURE)
matrix_3x3 bed_level_matrix; // Transform to compensate for bed level
#endif
void plan_buffer_line(const float& x, const float& y, const float& z, const float& e, float feed_rate, const uint8_t extruder); private:
void plan_set_position(const float& x, const float& y, const float& z, const float& e);
#endif // AUTO_BED_LEVELING_FEATURE || MESH_BED_LEVELING /**
* The current position of the tool in absolute steps
* Reclculated if any axis_steps_per_unit are changed by gcode
*/
long position[NUM_AXIS] = { 0 };
void plan_set_e_position(const float& e); /**
* Speed of previous path line segment
*/
float previous_speed[NUM_AXIS];
//=========================================================================== /**
//============================= public variables ============================ * Nominal speed of previous path line segment
//=========================================================================== */
float previous_nominal_speed;
extern millis_t minsegmenttime; #if ENABLED(DISABLE_INACTIVE_EXTRUDER)
extern float max_feedrate[NUM_AXIS]; // Max speeds in mm per minute /**
extern float axis_steps_per_unit[NUM_AXIS]; * Counters to manage disabling inactive extruders
extern unsigned long max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software */
extern float minimumfeedrate; uint8_t g_uc_extruder_last_move[EXTRUDERS] = { 0 };
extern float acceleration; // Normal acceleration mm/s^2 DEFAULT ACCELERATION for all printing moves. M204 SXXXX #endif // DISABLE_INACTIVE_EXTRUDER
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) #ifdef XY_FREQUENCY_LIMIT
extern bool autotemp_enabled; // Used for the frequency limit
extern float autotemp_max; #define MAX_FREQ_TIME (1000000.0/XY_FREQUENCY_LIMIT)
extern float autotemp_min; // Old direction bits. Used for speed calculations
extern float autotemp_factor; static unsigned char old_direction_bits = 0;
#endif // Segment times (in µs). Used for speed calculations
static long axis_segment_time[2][3] = { {MAX_FREQ_TIME + 1, 0, 0}, {MAX_FREQ_TIME + 1, 0, 0} };
#endif
extern block_t block_buffer[BLOCK_BUFFER_SIZE]; // A ring buffer for motion instructions #if ENABLED(DUAL_X_CARRIAGE)
extern volatile unsigned char block_buffer_head; // Index of the next block to be pushed extern bool extruder_duplication_enabled;
extern volatile unsigned char block_buffer_tail; #endif
// Returns true if the buffer has a queued block, false otherwise public:
FORCE_INLINE bool blocks_queued() { return (block_buffer_head != block_buffer_tail); }
// Called when the current block is no longer needed. Discards Planner();
// 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 void init();
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(); void reset_acceleration_rates();
// Manage fans, paste pressure, etc.
void check_axes_activity();
/**
* Number of moves currently in the planner
*/
FORCE_INLINE uint8_t movesplanned() { return BLOCK_MOD(block_buffer_head - block_buffer_tail + BLOCK_BUFFER_SIZE); }
#if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(MESH_BED_LEVELING)
#if ENABLED(AUTO_BED_LEVELING_FEATURE)
/**
* The corrected position, applying the bed level matrix
*/
vector_3 adjusted_position();
#endif
/**
* Add a new linear movement to the buffer.
*
* x,y,z,e - target position in mm
* feed_rate - (target) speed of the move
* extruder - target extruder
*/
void buffer_line(float x, float y, float z, const float& e, float feed_rate, const uint8_t extruder);
/**
* Set the planner.position and individual stepper positions.
* Used by G92, G28, G29, and other procedures.
*
* Multiplies by axis_steps_per_unit[] and does necessary conversion
* for COREXY / COREXZ to set the corresponding stepper positions.
*
* Clears previous speed values.
*/
void set_position(float x, float y, float z, const float& e);
#else
void buffer_line(const float& x, const float& y, const float& z, const float& e, float feed_rate, const uint8_t extruder);
void set_position(const float& x, const float& y, const float& z, const float& e);
#endif // AUTO_BED_LEVELING_FEATURE || MESH_BED_LEVELING
/**
* Set the E position (mm) of the planner (and the E stepper)
*/
void set_e_position(const float& e);
/**
* Does the buffer have any blocks queued?
*/
FORCE_INLINE bool blocks_queued() { return (block_buffer_head != block_buffer_tail); }
/**
* "Discards" the block and "releases" the memory.
* Called when the current block is no longer needed.
*/
FORCE_INLINE void discard_current_block() {
if (blocks_queued())
block_buffer_tail = BLOCK_MOD(block_buffer_tail + 1);
}
/**
* The current block. NULL if the buffer is empty.
* This also marks the block as busy.
*/
FORCE_INLINE block_t* get_current_block() {
if (blocks_queued()) {
block_t* block = &block_buffer[block_buffer_tail];
block->busy = true;
return block;
}
else
return NULL;
}
/**
* Get the index of the next / previous block in the ring buffer
*/
FORCE_INLINE int8_t next_block_index(int8_t block_index) { return BLOCK_MOD(block_index + 1); }
FORCE_INLINE int8_t prev_block_index(int8_t block_index) { return BLOCK_MOD(block_index - 1); }
/**
* Calculate the distance (not time) it takes to accelerate
* from initial_rate to target_rate using the given acceleration:
*/
FORCE_INLINE float estimate_acceleration_distance(float initial_rate, float target_rate, float acceleration) {
if (acceleration == 0) return 0; // acceleration was 0, set acceleration distance to 0
return (target_rate * target_rate - initial_rate * initial_rate) / (acceleration * 2);
}
/**
* Return the point at which you must start braking (at the rate of -'acceleration') if
* you start at 'initial_rate', accelerate (until reaching the point), and want to end at
* 'final_rate' after traveling 'distance'.
*
* This is used to compute the intersection point between acceleration and deceleration
* in cases where the "trapezoid" has no plateau (i.e., never reaches maximum speed)
*/
FORCE_INLINE float intersection_distance(float initial_rate, float final_rate, float acceleration, float distance) {
if (acceleration == 0) return 0; // acceleration was 0, set intersection distance to 0
return (acceleration * 2 * distance - initial_rate * initial_rate + final_rate * final_rate) / (acceleration * 4);
}
/**
* Calculate the maximum allowable speed at this point, in order
* to reach 'target_velocity' using 'acceleration' within a given
* 'distance'.
*/
FORCE_INLINE float max_allowable_speed(float acceleration, float target_velocity, float distance) {
return sqrt(target_velocity * target_velocity - 2 * acceleration * distance);
}
#if ENABLED(AUTOTEMP)
float autotemp_max = 250;
float autotemp_min = 210;
float autotemp_factor = 0.1;
bool autotemp_enabled = false;
void getHighESpeed();
void autotemp_M109();
#endif
private:
void calculate_trapezoid_for_block(block_t* block, float entry_factor, float exit_factor);
void reverse_pass_kernel(block_t* previous, block_t* current, block_t* next);
void forward_pass_kernel(block_t* previous, block_t* current, block_t* next);
void reverse_pass();
void forward_pass();
void recalculate_trapezoids();
void recalculate();
};
#endif // PLANNER_H #endif // PLANNER_H

12
Marlin/stepper.cpp
View file

@ -242,7 +242,7 @@ ISR(TIMER1_COMPA_vect) { stepper.isr(); }
void Stepper::isr() { void Stepper::isr() {
if (cleaning_buffer_counter) { if (cleaning_buffer_counter) {
current_block = NULL; current_block = NULL;
plan_discard_current_block(); planner.discard_current_block();
#ifdef SD_FINISHED_RELEASECOMMAND #ifdef SD_FINISHED_RELEASECOMMAND
if ((cleaning_buffer_counter == 1) && (SD_FINISHED_STEPPERRELEASE)) enqueue_and_echo_commands_P(PSTR(SD_FINISHED_RELEASECOMMAND)); if ((cleaning_buffer_counter == 1) && (SD_FINISHED_STEPPERRELEASE)) enqueue_and_echo_commands_P(PSTR(SD_FINISHED_RELEASECOMMAND));
#endif #endif
@ -254,7 +254,7 @@ void Stepper::isr() {
// If there is no current block, attempt to pop one from the buffer // If there is no current block, attempt to pop one from the buffer
if (!current_block) { if (!current_block) {
// Anything in the buffer? // Anything in the buffer?
current_block = plan_get_current_block(); current_block = planner.get_current_block();
if (current_block) { if (current_block) {
current_block->busy = true; current_block->busy = true;
trapezoid_generator_reset(); trapezoid_generator_reset();
@ -396,7 +396,7 @@ void Stepper::isr() {
// If current block is finished, reset pointer // If current block is finished, reset pointer
if (step_events_completed >= current_block->step_event_count) { if (step_events_completed >= current_block->step_event_count) {
current_block = NULL; current_block = NULL;
plan_discard_current_block(); planner.discard_current_block();
} }
} }
} }
@ -620,7 +620,7 @@ void Stepper::init() {
/** /**
* Block until all buffered steps are executed * Block until all buffered steps are executed
*/ */
void Stepper::synchronize() { while (blocks_queued()) idle(); } void Stepper::synchronize() { while (planner.blocks_queued()) idle(); }
/** /**
* Set the stepper positions directly in steps * Set the stepper positions directly in steps
@ -693,7 +693,7 @@ float Stepper::get_axis_position_mm(AxisEnum axis) {
#else #else
axis_steps = position(axis); axis_steps = position(axis);
#endif #endif
return axis_steps / axis_steps_per_unit[axis]; return axis_steps / planner.axis_steps_per_unit[axis];
} }
void Stepper::finish_and_disable() { void Stepper::finish_and_disable() {
@ -704,7 +704,7 @@ void Stepper::finish_and_disable() {
void Stepper::quick_stop() { void Stepper::quick_stop() {
cleaning_buffer_counter = 5000; cleaning_buffer_counter = 5000;
DISABLE_STEPPER_DRIVER_INTERRUPT(); DISABLE_STEPPER_DRIVER_INTERRUPT();
while (blocks_queued()) plan_discard_current_block(); while (planner.blocks_queued()) planner.discard_current_block();
current_block = NULL; current_block = NULL;
ENABLE_STEPPER_DRIVER_INTERRUPT(); ENABLE_STEPPER_DRIVER_INTERRUPT();
} }

2
Marlin/stepper.h
View file

@ -245,7 +245,7 @@ class Stepper {
// Triggered position of an axis in mm (not core-savvy) // Triggered position of an axis in mm (not core-savvy)
// //
FORCE_INLINE float triggered_position_mm(AxisEnum axis) { FORCE_INLINE float triggered_position_mm(AxisEnum axis) {
return endstops_trigsteps[axis] / axis_steps_per_unit[axis]; return endstops_trigsteps[axis] / planner.axis_steps_per_unit[axis];
} }
FORCE_INLINE unsigned short calc_timer(unsigned short step_rate) { FORCE_INLINE unsigned short calc_timer(unsigned short step_rate) {

2
Marlin/temperature.cpp
View file

@ -613,7 +613,7 @@ float get_pid_output(int e) {
lpq[lpq_ptr++] = 0; lpq[lpq_ptr++] = 0;
} }
if (lpq_ptr >= lpq_len) 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]; pid_output += cTerm[e];
} }
#endif //PID_ADD_EXTRUSION_RATE #endif //PID_ADD_EXTRUSION_RATE

10
Marlin/temperature.h
View file

@ -79,6 +79,10 @@ extern float current_temperature_bed;
extern unsigned char soft_pwm_bed; extern unsigned char soft_pwm_bed;
#endif #endif
#if ENABLED(FAN_SOFT_PWM)
extern unsigned char fanSpeedSoftPwm[FAN_COUNT];
#endif
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
#if ENABLED(PID_PARAMS_PER_EXTRUDER) #if ENABLED(PID_PARAMS_PER_EXTRUDER)
@ -178,9 +182,9 @@ void checkExtruderAutoFans();
FORCE_INLINE void autotempShutdown() { FORCE_INLINE void autotempShutdown() {
#if ENABLED(AUTOTEMP) #if ENABLED(AUTOTEMP)
if (autotemp_enabled) { if (planner.autotemp_enabled) {
autotemp_enabled = false; planner.autotemp_enabled = false;
if (degTargetHotend(active_extruder) > autotemp_min) if (degTargetHotend(active_extruder) > planner.autotemp_min)
setTargetHotend(0, active_extruder); setTargetHotend(0, active_extruder);
} }
#endif #endif

68
Marlin/ultralcd.cpp
View file

@ -463,9 +463,9 @@ static void lcd_status_screen() {
inline void line_to_current(AxisEnum axis) { inline void line_to_current(AxisEnum axis) {
#if ENABLED(DELTA) #if ENABLED(DELTA)
calculate_delta(current_position); 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 #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 #endif
} }
@ -495,7 +495,7 @@ inline void line_to_current(AxisEnum axis) {
static void lcd_main_menu() { static void lcd_main_menu() {
START_MENU(); START_MENU();
MENU_ITEM(back, MSG_WATCH); MENU_ITEM(back, MSG_WATCH);
if (movesplanned() || IS_SD_PRINTING) { if (planner.movesplanned() || IS_SD_PRINTING) {
MENU_ITEM(submenu, MSG_TUNE, lcd_tune_menu); MENU_ITEM(submenu, MSG_TUNE, lcd_tune_menu);
} }
else { else {
@ -934,7 +934,7 @@ void lcd_cooldown() {
ENCODER_DIRECTION_NORMAL(); ENCODER_DIRECTION_NORMAL();
// Encoder wheel adjusts the Z position // Encoder wheel adjusts the Z position
if (encoderPosition && movesplanned() <= 3) { if (encoderPosition && planner.movesplanned() <= 3) {
refresh_cmd_timeout(); refresh_cmd_timeout();
current_position[Z_AXIS] += float((int32_t)encoderPosition) * (MBL_Z_STEP); current_position[Z_AXIS] += float((int32_t)encoderPosition) * (MBL_Z_STEP);
NOLESS(current_position[Z_AXIS], 0); NOLESS(current_position[Z_AXIS], 0);
@ -1037,7 +1037,7 @@ void lcd_cooldown() {
if (LCD_CLICKED) { if (LCD_CLICKED) {
_lcd_level_bed_position = 0; _lcd_level_bed_position = 0;
current_position[Z_AXIS] = MESH_HOME_SEARCH_Z; 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); 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) { static void _lcd_move(const char* name, AxisEnum axis, float min, float max) {
ENCODER_DIRECTION_NORMAL(); ENCODER_DIRECTION_NORMAL();
if (encoderPosition && movesplanned() <= 3) { if (encoderPosition && planner.movesplanned() <= 3) {
refresh_cmd_timeout(); refresh_cmd_timeout();
current_position[axis] += float((int32_t)encoderPosition) * move_menu_scale; current_position[axis] += float((int32_t)encoderPosition) * move_menu_scale;
if (min_software_endstops) NOLESS(current_position[axis], min); 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; unsigned short original_active_extruder = active_extruder;
active_extruder = e; active_extruder = e;
#endif #endif
if (encoderPosition && movesplanned() <= 3) { if (encoderPosition && planner.movesplanned() <= 3) {
current_position[E_AXIS] += float((int32_t)encoderPosition) * move_menu_scale; current_position[E_AXIS] += float((int32_t)encoderPosition) * move_menu_scale;
line_to_current(E_AXIS); line_to_current(E_AXIS);
lcdDrawUpdate = LCDVIEW_REDRAW_NOW; lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
@ -1511,10 +1511,10 @@ static void lcd_control_temperature_menu() {
// Autotemp, Min, Max, Fact // Autotemp, Min, Max, Fact
// //
#if ENABLED(AUTOTEMP) && (TEMP_SENSOR_0 != 0) #if ENABLED(AUTOTEMP) && (TEMP_SENSOR_0 != 0)
MENU_ITEM_EDIT(bool, MSG_AUTOTEMP, &autotemp_enabled); MENU_ITEM_EDIT(bool, MSG_AUTOTEMP, &planner.autotemp_enabled);
MENU_ITEM_EDIT(float3, MSG_MIN, &autotemp_min, 0, HEATER_0_MAXTEMP - 15); MENU_ITEM_EDIT(float3, MSG_MIN, &planner.autotemp_min, 0, HEATER_0_MAXTEMP - 15);
MENU_ITEM_EDIT(float3, MSG_MAX, &autotemp_max, 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, &autotemp_factor, 0.0, 1.0); MENU_ITEM_EDIT(float32, MSG_FACTOR, &planner.autotemp_factor, 0.0, 1.0);
#endif #endif
// //
@ -1618,6 +1618,8 @@ static void lcd_control_temperature_preheat_abs_settings_menu() {
END_MENU(); END_MENU();
} }
static void _reset_acceleration_rates() { planner.reset_acceleration_rates(); }
/** /**
* *
* "Control" > "Motion" submenu * "Control" > "Motion" submenu
@ -1633,34 +1635,34 @@ static void lcd_control_motion_menu() {
#if ENABLED(MANUAL_BED_LEVELING) #if ENABLED(MANUAL_BED_LEVELING)
MENU_ITEM_EDIT(float43, MSG_BED_Z, &mbl.z_offset, -1, 1); MENU_ITEM_EDIT(float43, MSG_BED_Z, &mbl.z_offset, -1, 1);
#endif #endif
MENU_ITEM_EDIT(float5, MSG_ACC, &acceleration, 10, 99000); MENU_ITEM_EDIT(float5, MSG_ACC, &planner.acceleration, 10, 99000);
MENU_ITEM_EDIT(float3, MSG_VXY_JERK, &max_xy_jerk, 1, 990); MENU_ITEM_EDIT(float3, MSG_VXY_JERK, &planner.max_xy_jerk, 1, 990);
#if ENABLED(DELTA) #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 #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 #endif
MENU_ITEM_EDIT(float3, MSG_VE_JERK, &max_e_jerk, 1, 990); MENU_ITEM_EDIT(float3, MSG_VE_JERK, &planner.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_X, &planner.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_Y, &planner.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_Z, &planner.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_VMAX MSG_E, &planner.max_feedrate[E_AXIS], 1, 999);
MENU_ITEM_EDIT(float3, MSG_VMIN, &minimumfeedrate, 0, 999); MENU_ITEM_EDIT(float3, MSG_VMIN, &planner.min_feedrate, 0, 999);
MENU_ITEM_EDIT(float3, MSG_VTRAV_MIN, &mintravelfeedrate, 0, 999); MENU_ITEM_EDIT(float3, MSG_VTRAV_MIN, &planner.min_travel_feedrate, 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_X, &planner.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_Y, &planner.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_Z, &planner.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_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, &retract_acceleration, 100, 99000); MENU_ITEM_EDIT(float5, MSG_A_RETRACT, &planner.retract_acceleration, 100, 99000);
MENU_ITEM_EDIT(float5, MSG_A_TRAVEL, &travel_acceleration, 100, 99000); MENU_ITEM_EDIT(float5, MSG_A_TRAVEL, &planner.travel_acceleration, 100, 99000);
MENU_ITEM_EDIT(float52, MSG_XSTEPS, &axis_steps_per_unit[X_AXIS], 5, 9999); MENU_ITEM_EDIT(float52, MSG_XSTEPS, &planner.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(float52, MSG_YSTEPS, &planner.axis_steps_per_unit[Y_AXIS], 5, 9999);
#if ENABLED(DELTA) #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 #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 #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) #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
MENU_ITEM_EDIT(bool, MSG_ENDSTOP_ABORT, &abort_on_endstop_hit); MENU_ITEM_EDIT(bool, MSG_ENDSTOP_ABORT, &abort_on_endstop_hit);
#endif #endif