forksand
/
marlin-lulzbot-laser
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #6697 from thinkyhead/bf_wednesday_cleanup

Browse Source 
Wednesday-Thursday cleaning up after
master
Scott Lahteine 8 years ago committed by GitHub
parent 91841d75c9 0e582bcfb7
commit 0d48fd4b6b
11 changed files with 217 additions and 282 deletions
Show Stats Download Patch File Download Diff File

13
Marlin/Conditionals_post.h
Unescape View File

@ -731,15 +731,12 @@
* Set granular options based on the specific type of leveling * Set granular options based on the specific type of leveling
*/ */
#if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(DELTA) #define UBL_DELTA (ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(DELTA))
#define UBL_DELTA
#endif
#define ABL_PLANAR (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT)) #define ABL_PLANAR (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT))
#define ABL_GRID (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)) #define ABL_GRID (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR))
#define HAS_ABL (ABL_PLANAR || ABL_GRID || ENABLED(AUTO_BED_LEVELING_UBL)) #define HAS_ABL (ABL_PLANAR || ABL_GRID || ENABLED(AUTO_BED_LEVELING_UBL))
#define HAS_LEVELING (HAS_ABL || ENABLED(MESH_BED_LEVELING)) #define HAS_LEVELING (HAS_ABL || ENABLED(MESH_BED_LEVELING))
#define PLANNER_LEVELING (ABL_PLANAR || ABL_GRID || ENABLED(MESH_BED_LEVELING) || ENABLED(UBL_DELTA)) #define PLANNER_LEVELING (ABL_PLANAR || ABL_GRID || ENABLED(MESH_BED_LEVELING) || UBL_DELTA)
#define HAS_PROBING_PROCEDURE (HAS_ABL || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)) #define HAS_PROBING_PROCEDURE (HAS_ABL || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST))
#if HAS_PROBING_PROCEDURE #if HAS_PROBING_PROCEDURE
#define PROBE_BED_WIDTH abs(RIGHT_PROBE_BED_POSITION - (LEFT_PROBE_BED_POSITION)) #define PROBE_BED_WIDTH abs(RIGHT_PROBE_BED_POSITION - (LEFT_PROBE_BED_POSITION))
@ -823,8 +820,7 @@
/** /**
* DELTA_SEGMENT_MIN_LENGTH for UBL_DELTA * DELTA_SEGMENT_MIN_LENGTH for UBL_DELTA
*/ */
#if UBL_DELTA
#if ENABLED(UBL_DELTA)
#ifndef DELTA_SEGMENT_MIN_LENGTH #ifndef DELTA_SEGMENT_MIN_LENGTH
#if IS_SCARA #if IS_SCARA
#define DELTA_SEGMENT_MIN_LENGTH 0.25 // SCARA minimum segment size is 0.25mm #define DELTA_SEGMENT_MIN_LENGTH 0.25 // SCARA minimum segment size is 0.25mm
@ -836,4 +832,7 @@
#endif #endif
#endif #endif
// Shorthand
#define GRID_MAX_POINTS ((GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y))
#endif // CONDITIONALS_POST_H #endif // CONDITIONALS_POST_H

72
Marlin/G26_Mesh_Validation_Tool.cpp
Unescape View File

@ -100,7 +100,7 @@
* 'n' can be used instead if your host program does not appreciate you using 'N'. * 'n' can be used instead if your host program does not appreciate you using 'N'.
* *
* O # Ooooze How much your nozzle will Ooooze filament while getting in position to print. This * O # Ooooze How much your nozzle will Ooooze filament while getting in position to print. This
* is over kill, but using this parameter will let you get the very first 'cicle' perfect * is over kill, but using this parameter will let you get the very first 'circle' perfect
* so you have a trophy to peel off of the bed and hang up to show how perfectly you have your * so you have a trophy to peel off of the bed and hang up to show how perfectly you have your
* Mesh calibrated. If not specified, a filament length of .3mm is assumed. * Mesh calibrated. If not specified, a filament length of .3mm is assumed.
* *
@ -152,7 +152,7 @@
bool turn_on_heaters(); bool turn_on_heaters();
bool prime_nozzle(); bool prime_nozzle();
static uint16_t circle_flags[16], horizontal_mesh_line_flags[16], vertical_mesh_line_flags[16], continue_with_closest = 0; static uint16_t circle_flags[16], horizontal_mesh_line_flags[16], vertical_mesh_line_flags[16];
float g26_e_axis_feedrate = 0.020, float g26_e_axis_feedrate = 0.020,
random_deviation = 0.0, random_deviation = 0.0,
layer_height = LAYER_HEIGHT; layer_height = LAYER_HEIGHT;
@ -176,7 +176,7 @@
static int8_t prime_flag = 0; static int8_t prime_flag = 0;
static bool keep_heaters_on = false; static bool continue_with_closest, keep_heaters_on;
static int16_t g26_repeats; static int16_t g26_repeats;
@ -278,8 +278,7 @@
// If this mesh location is outside the printable_radius, skip it. // If this mesh location is outside the printable_radius, skip it.
if ( ! position_is_reachable_raw_xy( circle_x, circle_y )) if (!position_is_reachable_raw_xy(circle_x, circle_y)) continue;
continue;
xi = location.x_index; // Just to shrink the next few lines and make them easier to understand xi = location.x_index; // Just to shrink the next few lines and make them easier to understand
yi = location.y_index; yi = location.y_index;
@ -329,9 +328,7 @@
ye = circle_y + sin_table[tmp_div_30 + 1]; ye = circle_y + sin_table[tmp_div_30 + 1];
#if IS_KINEMATIC #if IS_KINEMATIC
// Check to make sure this segment is entirely on the bed, skip if not. // Check to make sure this segment is entirely on the bed, skip if not.
if (( ! position_is_reachable_raw_xy( x , y )) || if (!position_is_reachable_raw_xy(x, y) || !position_is_reachable_raw_xy(xe, ye)) continue;
( ! position_is_reachable_raw_xy( xe, ye )))
continue;
#else // not, we need to skip #else // not, we need to skip
x = constrain(x, X_MIN_POS + 1, X_MAX_POS - 1); // This keeps us from bumping the endstops x = constrain(x, X_MIN_POS + 1, X_MAX_POS - 1); // This keeps us from bumping the endstops
y = constrain(y, Y_MIN_POS + 1, Y_MAX_POS - 1); y = constrain(y, Y_MIN_POS + 1, Y_MAX_POS - 1);
@ -361,7 +358,7 @@
//debug_current_and_destination(PSTR("Done with current circle.")); //debug_current_and_destination(PSTR("Done with current circle."));
} while (location.x_index >= 0 && location.y_index >= 0 && g26_repeats--); } while (--g26_repeats && location.x_index >= 0 && location.y_index >= 0);
LEAVE: LEAVE:
lcd_reset_alert_level(); lcd_reset_alert_level();
@ -459,8 +456,7 @@
sy = ey = constrain(pgm_read_float(&ubl.mesh_index_to_ypos[j]), Y_MIN_POS + 1, Y_MAX_POS - 1); sy = ey = constrain(pgm_read_float(&ubl.mesh_index_to_ypos[j]), Y_MIN_POS + 1, Y_MAX_POS - 1);
ex = constrain(ex, X_MIN_POS + 1, X_MAX_POS - 1); ex = constrain(ex, X_MIN_POS + 1, X_MAX_POS - 1);
if (( position_is_reachable_raw_xy( sx, sy )) && if (position_is_reachable_raw_xy(sx, sy) && position_is_reachable_raw_xy(ex, ey)) {
( position_is_reachable_raw_xy( ex, ey ))) {
if (ubl.g26_debug_flag) { if (ubl.g26_debug_flag) {
SERIAL_ECHOPAIR(" Connecting with horizontal line (sx=", sx); SERIAL_ECHOPAIR(" Connecting with horizontal line (sx=", sx);
@ -494,8 +490,7 @@
sy = constrain(sy, Y_MIN_POS + 1, Y_MAX_POS - 1); sy = constrain(sy, Y_MIN_POS + 1, Y_MAX_POS - 1);
ey = constrain(ey, Y_MIN_POS + 1, Y_MAX_POS - 1); ey = constrain(ey, Y_MIN_POS + 1, Y_MAX_POS - 1);
if (( position_is_reachable_raw_xy( sx, sy )) && if (position_is_reachable_raw_xy(sx, sy) && position_is_reachable_raw_xy(ex, ey)) {
( position_is_reachable_raw_xy( ex, ey ))) {
if (ubl.g26_debug_flag) { if (ubl.g26_debug_flag) {
SERIAL_ECHOPAIR(" Connecting with vertical line (sx=", sx); SERIAL_ECHOPAIR(" Connecting with vertical line (sx=", sx);
@ -623,8 +618,8 @@
//if (ubl.g26_debug_flag) SERIAL_ECHOLNPGM(" Z bumping by 0.500 to minimize scraping."); //if (ubl.g26_debug_flag) SERIAL_ECHOLNPGM(" Z bumping by 0.500 to minimize scraping.");
//todo: parameterize the bump height with a define //todo: parameterize the bump height with a define
move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]+0.500, 0.0); // Z bump to minimize scraping move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + 0.500, 0.0); // Z bump to minimize scraping
move_to(sx, sy, sz+0.500, 0.0); // Get to the starting point with no extrusion while bumped move_to(sx, sy, sz + 0.500, 0.0); // Get to the starting point with no extrusion while bumped
} }
move_to(sx, sy, sz, 0.0); // Get to the starting point with no extrusion / un-Z bump move_to(sx, sy, sz, 0.0); // Get to the starting point with no extrusion / un-Z bump
@ -655,9 +650,11 @@
prime_length = PRIME_LENGTH; prime_length = PRIME_LENGTH;
bed_temp = BED_TEMP; bed_temp = BED_TEMP;
hotend_temp = HOTEND_TEMP; hotend_temp = HOTEND_TEMP;
ooze_amount = OOZE_AMOUNT;
prime_flag = 0; prime_flag = 0;
keep_heaters_on = false;
ooze_amount = code_seen('O') && code_has_value() ? code_value_linear_units() : OOZE_AMOUNT;
keep_heaters_on = code_seen('K') && code_value_bool();
continue_with_closest = code_seen('C') && code_value_bool();
if (code_seen('B')) { if (code_seen('B')) {
bed_temp = code_value_temp_abs(); bed_temp = code_value_temp_abs();
@ -667,8 +664,6 @@
} }
} }
if (code_seen('C')) continue_with_closest++;
if (code_seen('L')) { if (code_seen('L')) {
layer_height = code_value_linear_units(); layer_height = code_value_linear_units();
if (!WITHIN(layer_height, 0.0, 2.0)) { if (!WITHIN(layer_height, 0.0, 2.0)) {
@ -691,7 +686,7 @@
} }
} }
if (code_seen('N') || code_seen('n')) { if (code_seen('N') || code_seen('n')) { // Warning! Use of 'N' / lowercase flouts established standards.
nozzle = code_value_float(); nozzle = code_value_float();
if (!WITHIN(nozzle, 0.1, 1.0)) { if (!WITHIN(nozzle, 0.1, 1.0)) {
SERIAL_PROTOCOLLNPGM("?Specified nozzle size not plausible."); SERIAL_PROTOCOLLNPGM("?Specified nozzle size not plausible.");
@ -699,11 +694,6 @@
} }
} }
if (code_seen('K')) keep_heaters_on++;
if (code_seen('O') && code_has_value())
ooze_amount = code_value_linear_units();
if (code_seen('P')) { if (code_seen('P')) {
if (!code_has_value()) if (!code_has_value())
prime_flag = -1; prime_flag = -1;
@ -738,35 +728,21 @@
} }
} }
if (code_seen('M')) { if (code_seen('M')) { // Warning! Use of 'M' flouts established standards.
randomSeed(millis()); randomSeed(millis());
// This setting will persist for the next G26
random_deviation = code_has_value() ? code_value_float() : 50.0; random_deviation = code_has_value() ? code_value_float() : 50.0;
} }
if (code_seen('R')) { g26_repeats = code_seen('R') ? (code_has_value() ? code_value_int() : 999) : 1;
g26_repeats = code_has_value() ? code_value_int() : 999; if (g26_repeats < 1) {
SERIAL_PROTOCOLLNPGM("?(R)epeat value not plausible; must be at least 1.");
if (g26_repeats <= 0) { return UBL_ERR;
SERIAL_PROTOCOLLNPGM("?(R)epeat value not plausible; must be greater than 0.");
return UBL_ERR;
}
g26_repeats--;
}
x_pos = current_position[X_AXIS];
y_pos = current_position[Y_AXIS];
if (code_seen('X')) {
x_pos = code_value_float();
}
if (code_seen('Y')) {
y_pos = code_value_float();
} }
if ( ! position_is_reachable_xy( x_pos, y_pos )) { x_pos = code_seen('X') ? code_value_linear_units() : current_position[X_AXIS];
y_pos = code_seen('Y') ? code_value_linear_units() : current_position[Y_AXIS];
if (!position_is_reachable_xy(x_pos, y_pos)) {
SERIAL_PROTOCOLLNPGM("?Specified X,Y coordinate out of bounds."); SERIAL_PROTOCOLLNPGM("?Specified X,Y coordinate out of bounds.");
return UBL_ERR; return UBL_ERR;
} }

144
Marlin/Marlin_main.cpp
Unescape View File

@ -56,6 +56,8 @@
* G12 - Clean tool * G12 - Clean tool
* G20 - Set input units to inches * G20 - Set input units to inches
* G21 - Set input units to millimeters * G21 - Set input units to millimeters
* G26 - Mesh Validation Pattern (Requires UBL_G26_MESH_EDITING)
* G27 - Park Nozzle (Requires NOZZLE_PARK_FEATURE)
* G28 - Home one or more axes * G28 - Home one or more axes
* G29 - Detailed Z probe, probes the bed at 3 or more points. Will fail if you haven't homed yet. * G29 - Detailed Z probe, probes the bed at 3 or more points. Will fail if you haven't homed yet.
* G30 - Single Z probe, probes bed at X Y location (defaults to current XY location) * G30 - Single Z probe, probes bed at X Y location (defaults to current XY location)
@ -97,14 +99,15 @@
* M76 - Pause the print job timer. * M76 - Pause the print job timer.
* M77 - Stop the print job timer. * M77 - Stop the print job timer.
* M78 - Show statistical information about the print jobs. (Requires PRINTCOUNTER) * M78 - Show statistical information about the print jobs. (Requires PRINTCOUNTER)
* M80 - Turn on Power Supply. (Requires POWER_SUPPLY) * M80 - Turn on Power Supply. (Requires POWER_SUPPLY > 0)
* M81 - Turn off Power Supply. (Requires POWER_SUPPLY) * M81 - Turn off Power Supply. (Requires POWER_SUPPLY > 0)
* M82 - Set E codes absolute (default). * M82 - Set E codes absolute (default).
* M83 - Set E codes relative while in Absolute (G90) mode. * M83 - Set E codes relative while in Absolute (G90) mode.
* M84 - Disable steppers until next move, or use S<seconds> to specify an idle * M84 - Disable steppers until next move, or use S<seconds> to specify an idle
* duration after which steppers should turn off. S0 disables the timeout. * duration after which steppers should turn off. S0 disables 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 planner.axis_steps_per_mm for one or more axes. * M92 - Set planner.axis_steps_per_mm for one or more axes.
* M100 - Watch Free Memory (for debugging) (Requires M100_FREE_MEMORY_WATCHER)
* M104 - Set extruder target temp. * M104 - Set extruder target temp.
* M105 - Report current temperatures. * M105 - Report current temperatures.
* M106 - Fan on. * M106 - Fan on.
@ -210,7 +213,6 @@
* M364 - SCARA calibration: Move to cal-position PSIC (90 deg to Theta calibration position) * M364 - SCARA calibration: Move to cal-position PSIC (90 deg to Theta calibration position)
* *
* ************ Custom codes - This can change to suit future G-code regulations * ************ Custom codes - This can change to suit future G-code regulations
* M100 - Watch Free Memory (For Debugging). (Requires M100_FREE_MEMORY_WATCHER)
* M928 - Start SD logging: "M928 filename.gco". Stop with M29. (Requires SDSUPPORT) * M928 - Start SD logging: "M928 filename.gco". Stop with M29. (Requires SDSUPPORT)
* M999 - Restart after being stopped by error * M999 - Restart after being stopped by error
* *
@ -2425,9 +2427,12 @@ static void clean_up_after_endstop_or_probe_move() {
#elif ENABLED(AUTO_BED_LEVELING_UBL) #elif ENABLED(AUTO_BED_LEVELING_UBL)
#if ENABLED(UBL_DELTA) #if PLANNER_LEVELING
if (( ubl.state.active ) && ( ! enable )) { // leveling from on to off if (ubl.state.active != enable) {
planner.unapply_leveling(current_position); if (!enable) // leveling from on to off
planner.apply_leveling(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]);
else
planner.unapply_leveling(current_position);
} }
#endif #endif
@ -3729,7 +3734,7 @@ inline void gcode_G28() {
// Disable the leveling matrix before homing // Disable the leveling matrix before homing
#if HAS_LEVELING #if HAS_LEVELING
#if ENABLED(AUTO_BED_LEVELING_UBL) #if ENABLED(AUTO_BED_LEVELING_UBL)
const bool bed_leveling_state_at_entry = ubl.state.active; const bool ubl_state_at_entry = ubl.state.active;
#endif #endif
set_bed_leveling_enabled(false); set_bed_leveling_enabled(false);
#endif #endif
@ -3872,8 +3877,9 @@ inline void gcode_G28() {
// move to a height where we can use the full xy-area // move to a height where we can use the full xy-area
do_blocking_move_to_z(delta_clip_start_height); do_blocking_move_to_z(delta_clip_start_height);
#endif #endif
#if ENABLED(AUTO_BED_LEVELING_UBL) #if ENABLED(AUTO_BED_LEVELING_UBL)
set_bed_leveling_enabled(bed_leveling_state_at_entry); set_bed_leveling_enabled(ubl_state_at_entry);
#endif #endif
clean_up_after_endstop_or_probe_move(); clean_up_after_endstop_or_probe_move();
@ -4028,7 +4034,7 @@ void home_all_axes() { gcode_G28(); }
#endif #endif
} }
// If there's another point to sample, move there with optional lift. // If there's another point to sample, move there with optional lift.
if (mbl_probe_index < (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)) { if (mbl_probe_index < GRID_MAX_POINTS) {
mbl.zigzag(mbl_probe_index, px, py); mbl.zigzag(mbl_probe_index, px, py);
_manual_goto_xy(mbl.index_to_xpos[px], mbl.index_to_ypos[py]); _manual_goto_xy(mbl.index_to_xpos[px], mbl.index_to_ypos[py]);
@ -4247,8 +4253,6 @@ void home_all_axes() { gcode_G28(); }
ABL_VAR int left_probe_bed_position, right_probe_bed_position, front_probe_bed_position, back_probe_bed_position; ABL_VAR int left_probe_bed_position, right_probe_bed_position, front_probe_bed_position, back_probe_bed_position;
ABL_VAR float xGridSpacing, yGridSpacing; ABL_VAR float xGridSpacing, yGridSpacing;
#define ABL_GRID_MAX (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)
#if ABL_PLANAR #if ABL_PLANAR
ABL_VAR uint8_t abl_grid_points_x = GRID_MAX_POINTS_X, ABL_VAR uint8_t abl_grid_points_x = GRID_MAX_POINTS_X,
abl_grid_points_y = GRID_MAX_POINTS_Y; abl_grid_points_y = GRID_MAX_POINTS_Y;
@ -4262,7 +4266,7 @@ void home_all_axes() { gcode_G28(); }
#if ABL_PLANAR #if ABL_PLANAR
ABL_VAR int abl2; ABL_VAR int abl2;
#else // 3-point #else // 3-point
int constexpr abl2 = ABL_GRID_MAX; int constexpr abl2 = GRID_MAX_POINTS;
#endif #endif
#endif #endif
@ -4274,8 +4278,8 @@ void home_all_axes() { gcode_G28(); }
ABL_VAR int indexIntoAB[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y]; ABL_VAR int indexIntoAB[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
ABL_VAR float eqnAMatrix[ABL_GRID_MAX * 3], // "A" matrix of the linear system of equations ABL_VAR float eqnAMatrix[GRID_MAX_POINTS * 3], // "A" matrix of the linear system of equations
eqnBVector[ABL_GRID_MAX], // "B" vector of Z points eqnBVector[GRID_MAX_POINTS], // "B" vector of Z points
mean; mean;
#endif #endif
@ -7619,7 +7623,6 @@ inline void gcode_M205() {
if (code_seen('H')) { if (code_seen('H')) {
home_offset[Z_AXIS] = code_value_linear_units() - DELTA_HEIGHT; home_offset[Z_AXIS] = code_value_linear_units() - DELTA_HEIGHT;
current_position[Z_AXIS] += code_value_linear_units() - DELTA_HEIGHT - home_offset[Z_AXIS]; current_position[Z_AXIS] += code_value_linear_units() - DELTA_HEIGHT - home_offset[Z_AXIS];
home_offset[Z_AXIS] = code_value_linear_units() - DELTA_HEIGHT;
update_software_endstops(Z_AXIS); update_software_endstops(Z_AXIS);
} }
if (code_seen('L')) delta_diagonal_rod = code_value_linear_units(); if (code_seen('L')) delta_diagonal_rod = code_value_linear_units();
@ -8413,17 +8416,15 @@ void quickstop_stepper() {
* Use either 'M421 X<linear> Y<linear> Z<linear>' or 'M421 I<xindex> J<yindex> Z<linear>' * Use either 'M421 X<linear> Y<linear> Z<linear>' or 'M421 I<xindex> J<yindex> Z<linear>'
*/ */
inline void gcode_M421() { inline void gcode_M421() {
int8_t px = 0, py = 0;
float z = 0;
bool hasX, hasY, hasZ, hasI, hasJ;
if ((hasX = code_seen('X'))) px = mbl.probe_index_x(code_value_linear_units());
if ((hasY = code_seen('Y'))) py = mbl.probe_index_y(code_value_linear_units());
if ((hasI = code_seen('I'))) px = code_value_linear_units();
if ((hasJ = code_seen('J'))) py = code_value_linear_units();
if ((hasZ = code_seen('Z'))) z = code_value_linear_units();
if (hasX && hasY && hasZ) { const bool hasX = code_seen('X'), hasI = !hasX && code_seen('I');
const int8_t px = hasX || hasI ? mbl.probe_index_x(code_value_linear_units()) : 0;
const bool hasY = code_seen('Y'), hasJ = !hasY && code_seen('J');
const int8_t py = hasY || hasJ ? mbl.probe_index_y(code_value_linear_units()) : 0;
const bool hasZ = code_seen('Z');
const float z = hasZ ? code_value_linear_units() : 0;
if (hasX && hasY && hasZ) {
if (px >= 0 && py >= 0) if (px >= 0 && py >= 0)
mbl.set_z(px, py, z); mbl.set_z(px, py, z);
else { else {
@ -8450,18 +8451,18 @@ void quickstop_stepper() {
/** /**
* M421: Set a single Mesh Bed Leveling Z coordinate * M421: Set a single Mesh Bed Leveling Z coordinate
* *
* Usage:
* M421 I<xindex> J<yindex> Z<linear> * M421 I<xindex> J<yindex> Z<linear>
* or
* M421 I<xindex> J<yindex> Q<offset> * M421 I<xindex> J<yindex> Q<offset>
*/ */
inline void gcode_M421() { inline void gcode_M421() {
int8_t px = 0, py = 0;
float z = 0; const bool hasI = code_seen('I');
bool hasI, hasJ, hasZ, hasQ; const int8_t px = hasI ? code_value_int() : 0;
if ((hasI = code_seen('I'))) px = code_value_int(); const bool hasJ = code_seen('J');
if ((hasJ = code_seen('J'))) py = code_value_int(); const int8_t py = hasJ ? code_value_int() : 0;
if ((hasZ = code_seen('Z'))) z = code_value_linear_units(); const bool hasZ = code_seen('Z'), hasQ = !hasZ && code_seen('Q');
if ((hasQ = code_seen('Q'))) z = code_value_linear_units(); const float z = hasZ || hasQ ? code_value_linear_units() : 0;
if (!hasI || !hasJ || (hasQ && hasZ) || (!hasQ && !hasZ)) { if (!hasI || !hasJ || (hasQ && hasZ) || (!hasQ && !hasZ)) {
SERIAL_ERROR_START; SERIAL_ERROR_START;
@ -8494,35 +8495,33 @@ void quickstop_stepper() {
/** /**
* M421: Set a single Mesh Bed Leveling Z coordinate * M421: Set a single Mesh Bed Leveling Z coordinate
* *
* Usage:
* M421 I<xindex> J<yindex> Z<linear> * M421 I<xindex> J<yindex> Z<linear>
* or
* M421 I<xindex> J<yindex> Q<offset> * M421 I<xindex> J<yindex> Q<offset>
* M421 C Z<linear>
* M421 C Q<offset>
*/ */
//todo: change multiple points simultaneously?
inline void gcode_M421() { inline void gcode_M421() {
int8_t px = 0, py = 0;
float z = 0; // Get the closest position for 'C', if needed
bool hasI, hasJ, hasZ, hasQ, hasC; const mesh_index_pair location = find_closest_mesh_point_of_type(REAL, current_position[X_AXIS], current_position[Y_AXIS], USE_NOZZLE_AS_REFERENCE, NULL, false);
if ((hasI = code_seen('I'))) px = code_value_int();
if ((hasJ = code_seen('J'))) py = code_value_int(); const bool hasC = code_seen('C'), hasI = code_seen('I');
if ((hasZ = code_seen('Z'))) z = code_value_linear_units(); const int8_t px = hasC ? location.x_index : hasI ? code_value_int() : 0;
if ((hasQ = code_seen('Q'))) z = code_value_linear_units();
hasC = code_seen('C'); const bool hasJ = code_seen('J');
const int8_t py = hasC ? location.y_index : hasJ ? code_value_int() : 0;
if ( (!(hasI && hasJ) && !hasC) || (hasQ && hasZ) || (!hasQ && !hasZ)) {
const bool hasZ = code_seen('Z'), hasQ = !hasZ && code_seen('Q');
const float z = hasZ || hasQ ? code_value_linear_units() : 0;
if ( ((hasI && hasJ) == hasC) || (hasQ && hasZ) || (!hasQ && !hasZ)) {
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS); SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS);
return; return;
} }
if (hasC) { // get closest position
const mesh_index_pair location = find_closest_mesh_point_of_type(REAL, current_position[X_AXIS], current_position[Y_AXIS], USE_NOZZLE_AS_REFERENCE, NULL, false);
px = location.x_index;
py = location.y_index;
}
if (WITHIN(px, 0, GRID_MAX_POINTS_X - 1) && WITHIN(py, 0, GRID_MAX_POINTS_Y - 1)) { if (WITHIN(px, 0, GRID_MAX_POINTS_X - 1) && WITHIN(py, 0, GRID_MAX_POINTS_Y - 1)) {
if (hasZ) // doing an absolute mesh value if (hasZ) // doing an absolute mesh value
ubl.z_values[px][py] = z; ubl.z_values[px][py] = z;
@ -8534,7 +8533,8 @@ void quickstop_stepper() {
SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY); SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
} }
} }
#endif
#endif // AUTO_BED_LEVELING_UBL
#if HAS_M206_COMMAND #if HAS_M206_COMMAND
@ -11106,7 +11106,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
#endif // AUTO_BED_LEVELING_BILINEAR #endif // AUTO_BED_LEVELING_BILINEAR
#if IS_KINEMATIC && DISABLED(UBL_DELTA) #if IS_KINEMATIC && !UBL_DELTA
/** /**
* Prepare a linear move in a DELTA or SCARA setup. * Prepare a linear move in a DELTA or SCARA setup.
@ -11117,7 +11117,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
inline bool prepare_kinematic_move_to(float ltarget[XYZE]) { inline bool prepare_kinematic_move_to(float ltarget[XYZE]) {
// Get the top feedrate of the move in the XY plane // Get the top feedrate of the move in the XY plane
float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s); const float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s);
// If the move is only in Z/E don't split up the move // If the move is only in Z/E don't split up the move
if (ltarget[X_AXIS] == current_position[X_AXIS] && ltarget[Y_AXIS] == current_position[Y_AXIS]) { if (ltarget[X_AXIS] == current_position[X_AXIS] && ltarget[Y_AXIS] == current_position[Y_AXIS]) {
@ -11126,7 +11126,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
} }
// Fail if attempting move outside printable radius // Fail if attempting move outside printable radius
if ( ! position_is_reachable_xy( ltarget[X_AXIS], ltarget[Y_AXIS] )) return true; if (!position_is_reachable_xy(ltarget[X_AXIS], ltarget[Y_AXIS])) return true;
// Get the cartesian distances moved in XYZE // Get the cartesian distances moved in XYZE
float difference[XYZE]; float difference[XYZE];
@ -11142,7 +11142,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
if (UNEAR_ZERO(cartesian_mm)) return true; if (UNEAR_ZERO(cartesian_mm)) return true;
// Minimum number of seconds to move the given distance // Minimum number of seconds to move the given distance
float seconds = cartesian_mm / _feedrate_mm_s; const float seconds = cartesian_mm / _feedrate_mm_s;
// The number of segments-per-second times the duration // The number of segments-per-second times the duration
// gives the number of segments // gives the number of segments
@ -11227,7 +11227,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
return false; return false;
} }
#else // !IS_KINEMATIC #else // !IS_KINEMATIC || UBL_DELTA
/** /**
* Prepare a linear move in a Cartesian setup. * Prepare a linear move in a Cartesian setup.
@ -11265,7 +11265,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
return false; return false;
} }
#endif // !IS_KINEMATIC #endif // !IS_KINEMATIC || UBL_DELTA
#if ENABLED(DUAL_X_CARRIAGE) #if ENABLED(DUAL_X_CARRIAGE)
@ -11377,21 +11377,21 @@ void prepare_move_to_destination() {
#endif #endif
#if IS_KINEMATIC if (
#if ENABLED(UBL_DELTA) #if IS_KINEMATIC
if (ubl_prepare_linear_move_to(destination,feedrate_mm_s)) return; #if UBL_DELTA
#else ubl_prepare_linear_move_to(destination, feedrate_mm_s)
if (prepare_kinematic_move_to(destination)) return; #else
#endif prepare_kinematic_move_to(destination)
#else #endif
#if ENABLED(DUAL_X_CARRIAGE) #elif ENABLED(DUAL_X_CARRIAGE)
if (prepare_move_to_destination_dualx()) return; prepare_move_to_destination_dualx()
#elif ENABLED(UBL_DELTA) // will work for CARTESIAN too (smaller segments follow mesh more closely) #elif UBL_DELTA // will work for CARTESIAN too (smaller segments follow mesh more closely)
if (ubl_prepare_linear_move_to(destination,feedrate_mm_s)) return; ubl_prepare_linear_move_to(destination, feedrate_mm_s)
#else #else
if (prepare_move_to_destination_cartesian()) return; prepare_move_to_destination_cartesian()
#endif #endif
#endif ) return;
set_current_to_destination(); set_current_to_destination();
} }
@ -11432,7 +11432,7 @@ void prepare_move_to_destination() {
if (angular_travel == 0 && current_position[X_AXIS] == logical[X_AXIS] && current_position[Y_AXIS] == logical[Y_AXIS]) if (angular_travel == 0 && current_position[X_AXIS] == logical[X_AXIS] && current_position[Y_AXIS] == logical[Y_AXIS])
angular_travel += RADIANS(360); angular_travel += RADIANS(360);
float mm_of_travel = HYPOT(angular_travel * radius, fabs(linear_travel)); const float mm_of_travel = HYPOT(angular_travel * radius, fabs(linear_travel));
if (mm_of_travel < 0.001) return; if (mm_of_travel < 0.001) return;
uint16_t segments = floor(mm_of_travel / (MM_PER_ARC_SEGMENT)); uint16_t segments = floor(mm_of_travel / (MM_PER_ARC_SEGMENT));

29
Marlin/SanityCheck.h
Unescape View File

@ -248,11 +248,9 @@
#if ENABLED(DELTA) #if ENABLED(DELTA)
#if DISABLED(USE_XMAX_PLUG) && DISABLED(USE_YMAX_PLUG) && DISABLED(USE_ZMAX_PLUG) #if DISABLED(USE_XMAX_PLUG) && DISABLED(USE_YMAX_PLUG) && DISABLED(USE_ZMAX_PLUG)
#error "You probably want to use Max Endstops for DELTA!" #error "You probably want to use Max Endstops for DELTA!"
#endif #elif ENABLED(ENABLE_LEVELING_FADE_HEIGHT) && DISABLED(AUTO_BED_LEVELING_BILINEAR) && !UBL_DELTA
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) && DISABLED(UBL_DELTA) #error "ENABLE_LEVELING_FADE_HEIGHT on DELTA requires AUTO_BED_LEVELING_BILINEAR or AUTO_BED_LEVELING_UBL."
#error "ENABLE_LEVELING_FADE_HEIGHT for DELTA requires UBL_DELTA and AUTO_BED_LEVELING_UBL." #elif ABL_GRID
#endif
#if ABL_GRID
#if (GRID_MAX_POINTS_X & 1) == 0 || (GRID_MAX_POINTS_Y & 1) == 0 #if (GRID_MAX_POINTS_X & 1) == 0 || (GRID_MAX_POINTS_Y & 1) == 0
#error "DELTA requires GRID_MAX_POINTS_X and GRID_MAX_POINTS_Y to be odd numbers." #error "DELTA requires GRID_MAX_POINTS_X and GRID_MAX_POINTS_Y to be odd numbers."
#elif GRID_MAX_POINTS_X < 3 #elif GRID_MAX_POINTS_X < 3
@ -431,20 +429,11 @@ static_assert(1 >= 0
* Unified Bed Leveling * Unified Bed Leveling
*/ */
#if ENABLED(AUTO_BED_LEVELING_UBL) #if ENABLED(AUTO_BED_LEVELING_UBL)
#if IS_KINEMATIC #if IS_SCARA
#if ENABLED(DELTA) #error "AUTO_BED_LEVELING_UBL does not yet support SCARA printers."
#if DISABLED(UBL_DELTA) #elif DISABLED(NEWPANEL)
#error "AUTO_BED_LEVELING_UBL requires UBL_DELTA for DELTA printers."
#endif
#else // SCARA
#error "AUTO_BED_LEVELING_UBL not supported for SCARA printers."
#endif
#endif
#if DISABLED(NEWPANEL)
#error "AUTO_BED_LEVELING_UBL requires an LCD controller." #error "AUTO_BED_LEVELING_UBL requires an LCD controller."
#endif #endif
#elif ENABLED(UBL_DELTA)
#error "UBL_DELTA requires AUTO_BED_LEVELING_UBL."
#endif #endif
/** /**
@ -603,10 +592,8 @@ static_assert(1 >= 0
/** /**
* Delta and SCARA have limited bed leveling options * Delta and SCARA have limited bed leveling options
*/ */
#if IS_KINEMATIC #if IS_SCARA && DISABLED(AUTO_BED_LEVELING_BILINEAR)
#if DISABLED(AUTO_BED_LEVELING_BILINEAR) && DISABLED(UBL_DELTA) #error "Only AUTO_BED_LEVELING_BILINEAR currently supports SCARA bed leveling."
#error "Only AUTO_BED_LEVELING_BILINEAR or AUTO_BED_LEVELING_UBL with UBL_DELTA support DELTA and SCARA bed leveling."
#endif
#endif #endif
/** /**

4
Marlin/configuration_store.cpp
Unescape View File

@ -342,7 +342,7 @@ void MarlinSettings::postprocess() {
#if ENABLED(MESH_BED_LEVELING) #if ENABLED(MESH_BED_LEVELING)
// Compile time test that sizeof(mbl.z_values) is as expected // Compile time test that sizeof(mbl.z_values) is as expected
static_assert( static_assert(
sizeof(mbl.z_values) == (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) * sizeof(mbl.z_values[0][0]), sizeof(mbl.z_values) == GRID_MAX_POINTS * sizeof(mbl.z_values[0][0]),
"MBL Z array is the wrong size." "MBL Z array is the wrong size."
); );
const bool leveling_is_on = TEST(mbl.status, MBL_STATUS_HAS_MESH_BIT); const bool leveling_is_on = TEST(mbl.status, MBL_STATUS_HAS_MESH_BIT);
@ -386,7 +386,7 @@ void MarlinSettings::postprocess() {
#if ENABLED(AUTO_BED_LEVELING_BILINEAR) #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
// Compile time test that sizeof(z_values) is as expected // Compile time test that sizeof(z_values) is as expected
static_assert( static_assert(
sizeof(z_values) == (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) * sizeof(z_values[0][0]), sizeof(z_values) == GRID_MAX_POINTS * sizeof(z_values[0][0]),
"Bilinear Z array is the wrong size." "Bilinear Z array is the wrong size."
); );
const uint8_t grid_max_x = GRID_MAX_POINTS_X, grid_max_y = GRID_MAX_POINTS_Y; const uint8_t grid_max_x = GRID_MAX_POINTS_X, grid_max_y = GRID_MAX_POINTS_Y;

20
Marlin/planner.cpp
Unescape View File

@ -534,12 +534,12 @@ void Planner::check_axes_activity() {
*/ */
void Planner::apply_leveling(float &lx, float &ly, float &lz) { void Planner::apply_leveling(float &lx, float &ly, float &lz) {
#if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(UBL_DELTA) // probably should also be enabled for UBL without UBL_DELTA #if ENABLED(AUTO_BED_LEVELING_UBL) && UBL_DELTA // probably should also be enabled for UBL without UBL_DELTA
if (!ubl.state.active) return; if (!ubl.state.active) return;
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
// if z_fade_height enabled (nonzero) and raw_z above it, no leveling required // if z_fade_height enabled (nonzero) and raw_z above it, no leveling required
if ((planner.z_fade_height) && (planner.z_fade_height <= RAW_Z_POSITION(lz))) return; if ((planner.z_fade_height) && (planner.z_fade_height <= RAW_Z_POSITION(lz))) return;
lz += ubl.state.z_offset + ( ubl.get_z_correction(lx,ly) * ubl.fade_scaling_factor_for_z(lz)); lz += ubl.state.z_offset + ubl.get_z_correction(lx,ly) * ubl.fade_scaling_factor_for_z(lz);
#else // no fade #else // no fade
lz += ubl.state.z_offset + ubl.get_z_correction(lx,ly); lz += ubl.state.z_offset + ubl.get_z_correction(lx,ly);
#endif // FADE #endif // FADE
@ -598,13 +598,13 @@ void Planner::check_axes_activity() {
void Planner::unapply_leveling(float logical[XYZ]) { void Planner::unapply_leveling(float logical[XYZ]) {
#if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(UBL_DELTA) #if ENABLED(AUTO_BED_LEVELING_UBL) && UBL_DELTA
if ( ubl.state.active ) { if (ubl.state.active) {
float z_leveled = RAW_Z_POSITION(logical[Z_AXIS]); const float z_leveled = RAW_Z_POSITION(logical[Z_AXIS]),
float z_ublmesh = ubl.get_z_correction(logical[X_AXIS],logical[Y_AXIS]); z_ublmesh = ubl.get_z_correction(logical[X_AXIS], logical[Y_AXIS]);
float z_unlevel = z_leveled - ubl.state.z_offset - z_ublmesh; float z_unlevel = z_leveled - ubl.state.z_offset - z_ublmesh;
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
@ -616,9 +616,9 @@ void Planner::check_axes_activity() {
// so U(1-M/H)==L-O-M // so U(1-M/H)==L-O-M
// so U==(L-O-M)/(1-M/H) for U<H // so U==(L-O-M)/(1-M/H) for U<H
if ( planner.z_fade_height ) { if (planner.z_fade_height) {
float z_unfaded = z_unlevel / ( 1.0 - ( z_ublmesh * planner.inverse_z_fade_height )); float z_unfaded = z_unlevel / (1.0 - z_ublmesh * planner.inverse_z_fade_height);
if ( z_unfaded < planner.z_fade_height ) // don't know until after compute if (z_unfaded < planner.z_fade_height) // don't know until after compute
z_unlevel = z_unfaded; z_unlevel = z_unfaded;
} }

25
Marlin/ubl_G29.cpp
Unescape View File

@ -209,7 +209,7 @@
* Mesh Validation Pattern phase. Please note that you are populating your mesh with unverified * Mesh Validation Pattern phase. Please note that you are populating your mesh with unverified
* numbers. You should use some scrutiny and caution. * numbers. You should use some scrutiny and caution.
* *
* P4 Phase 4 Fine tune the Mesh. The Delta Mesh Compensation System assume the existance of * P4 Phase 4 Fine tune the Mesh. The Delta Mesh Compensation System assume the existence of
* an LCD Panel. It is possible to fine tune the mesh without the use of an LCD Panel. * an LCD Panel. It is possible to fine tune the mesh without the use of an LCD Panel.
* (More work and details on doing this later!) * (More work and details on doing this later!)
* The System will search for the closest Mesh Point to the nozzle. It will move the * The System will search for the closest Mesh Point to the nozzle. It will move the
@ -328,7 +328,8 @@
return; return;
} }
if (!code_seen('N') && axis_unhomed_error(true, true, true)) // Don't allow auto-leveling without homing first // Don't allow auto-leveling without homing first
if (!code_seen('N') && axis_unhomed_error(true, true, true)) // Warning! Use of 'N' flouts established standards.
home_all_axes(); home_all_axes();
if (g29_parameter_parsing()) return; // abort if parsing the simple parameters causes a problem, if (g29_parameter_parsing()) return; // abort if parsing the simple parameters causes a problem,
@ -385,7 +386,7 @@
if (code_seen('J')) { if (code_seen('J')) {
ubl.save_ubl_active_state_and_disable(); ubl.save_ubl_active_state_and_disable();
ubl.tilt_mesh_based_on_probed_grid(code_seen('O') || code_seen('M')); ubl.tilt_mesh_based_on_probed_grid(code_seen('O') || code_seen('M')); // Warning! Use of 'M' flouts established standards.
ubl.restore_ubl_active_state_and_leave(); ubl.restore_ubl_active_state_and_leave();
} }
@ -419,7 +420,7 @@
SERIAL_PROTOCOLLNPGM(").\n"); SERIAL_PROTOCOLLNPGM(").\n");
} }
ubl.probe_entire_mesh(x_pos + X_PROBE_OFFSET_FROM_EXTRUDER, y_pos + Y_PROBE_OFFSET_FROM_EXTRUDER, ubl.probe_entire_mesh(x_pos + X_PROBE_OFFSET_FROM_EXTRUDER, y_pos + Y_PROBE_OFFSET_FROM_EXTRUDER,
code_seen('O') || code_seen('M'), code_seen('E'), code_seen('U')); code_seen('O') || code_seen('M'), code_seen('E'), code_seen('U')); // Warning! Use of 'M' flouts established standards.
break; break;
case 2: { case 2: {
@ -468,7 +469,7 @@
return; return;
} }
manually_probe_remaining_mesh(x_pos, y_pos, height, card_thickness, code_seen('O') || code_seen('M')); manually_probe_remaining_mesh(x_pos, y_pos, height, card_thickness, code_seen('O') || code_seen('M')); // Warning! Use of 'M' flouts established standards.
SERIAL_PROTOCOLLNPGM("G29 P2 finished."); SERIAL_PROTOCOLLNPGM("G29 P2 finished.");
} break; } break;
@ -504,7 +505,7 @@
// //
// Fine Tune (i.e., Edit) the Mesh // Fine Tune (i.e., Edit) the Mesh
// //
fine_tune_mesh(x_pos, y_pos, code_seen('O') || code_seen('M')); fine_tune_mesh(x_pos, y_pos, code_seen('O') || code_seen('M')); // Warning! Use of 'M' flouts established standards.
break; break;
case 5: ubl.find_mean_mesh_height(); break; case 5: ubl.find_mean_mesh_height(); break;
@ -549,7 +550,7 @@
// When we are fully debugged, the EEPROM dump command will get deleted also. But // When we are fully debugged, the EEPROM dump command will get deleted also. But
// right now, it is good to have the extra information. Soon... we prune this. // right now, it is good to have the extra information. Soon... we prune this.
// //
if (code_seen('j')) g29_eeprom_dump(); // EEPROM Dump if (code_seen('j')) g29_eeprom_dump(); // Warning! Use of lowercase flouts established standards.
// //
// When we are fully debugged, this may go away. But there are some valid // When we are fully debugged, this may go away. But there are some valid
@ -613,7 +614,7 @@
SERIAL_PROTOCOLLNPGM("Done.\n"); SERIAL_PROTOCOLLNPGM("Done.\n");
} }
if (code_seen('O') || code_seen('M')) if (code_seen('O') || code_seen('M')) // Warning! Use of 'M' flouts established standards.
ubl.display_map(code_has_value() ? code_value_int() : 0); ubl.display_map(code_has_value() ? code_value_int() : 0);
if (code_seen('Z')) { if (code_seen('Z')) {
@ -1048,8 +1049,8 @@
repeat_flag = code_seen('R'); repeat_flag = code_seen('R');
if (repeat_flag) { if (repeat_flag) {
repetition_cnt = code_has_value() ? code_value_int() : (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y); repetition_cnt = code_has_value() ? code_value_int() : GRID_MAX_POINTS;
repetition_cnt = min(repetition_cnt, (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)); NOMORE(repetition_cnt, GRID_MAX_POINTS);
if (repetition_cnt < 1) { if (repetition_cnt < 1) {
SERIAL_PROTOCOLLNPGM("?(R)epetition count invalid (1+).\n"); SERIAL_PROTOCOLLNPGM("?(R)epetition count invalid (1+).\n");
return UBL_ERR; return UBL_ERR;
@ -1128,8 +1129,8 @@
SERIAL_PROTOCOLLNPGM("Invalid map type.\n"); SERIAL_PROTOCOLLNPGM("Invalid map type.\n");
return UBL_ERR; return UBL_ERR;
} }
// Check if a map type was specified
if (code_seen('M')) { // Check if a map type was specified if (code_seen('M')) { // Warning! Use of 'M' flouts established standards.
map_type = code_has_value() ? code_value_int() : 0; map_type = code_has_value() ? code_value_int() : 0;
if (!WITHIN(map_type, 0, 1)) { if (!WITHIN(map_type, 0, 1)) {
SERIAL_PROTOCOLLNPGM("Invalid map type.\n"); SERIAL_PROTOCOLLNPGM("Invalid map type.\n");

149
Marlin/ubl_motion.cpp
Unescape View File

@ -474,20 +474,10 @@
set_current_to_destination(); set_current_to_destination();
} }
#if UBL_DELTA
#ifdef UBL_DELTA
#define COPY_XYZE( target, source ) { \
target[X_AXIS] = source[X_AXIS]; \
target[Y_AXIS] = source[Y_AXIS]; \
target[Z_AXIS] = source[Z_AXIS]; \
target[E_AXIS] = source[E_AXIS]; \
}
#if IS_SCARA // scale the feed rate from mm/s to degrees/s #if IS_SCARA // scale the feed rate from mm/s to degrees/s
static float scara_feed_factor; static float scara_feed_factor, scara_oldA, scara_oldB;
static float scara_oldA;
static float scara_oldB;
#endif #endif
// We don't want additional apply_leveling() performed by regular buffer_line or buffer_line_kinematic, // We don't want additional apply_leveling() performed by regular buffer_line or buffer_line_kinematic,
@ -501,18 +491,18 @@
float feedrate = fr_mm_s; float feedrate = fr_mm_s;
#if IS_SCARA // scale the feed rate from mm/s to degrees/s #if IS_SCARA // scale the feed rate from mm/s to degrees/s
float adiff = abs(delta[A_AXIS] - scara_oldA); float adiff = abs(delta[A_AXIS] - scara_oldA),
float bdiff = abs(delta[B_AXIS] - scara_oldB); bdiff = abs(delta[B_AXIS] - scara_oldB);
scara_oldA = delta[A_AXIS]; scara_oldA = delta[A_AXIS];
scara_oldB = delta[B_AXIS]; scara_oldB = delta[B_AXIS];
feedrate = max(adiff, bdiff) * scara_feed_factor; feedrate = max(adiff, bdiff) * scara_feed_factor;
#endif #endif
planner._buffer_line( delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], ltarget[E_AXIS], feedrate, extruder ); planner._buffer_line(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], ltarget[E_AXIS], feedrate, extruder);
#else // cartesian #else // cartesian
planner._buffer_line( ltarget[X_AXIS], ltarget[Y_AXIS], ltarget[Z_AXIS], ltarget[E_AXIS], fr_mm_s, extruder ); planner._buffer_line(ltarget[X_AXIS], ltarget[Y_AXIS], ltarget[Z_AXIS], ltarget[E_AXIS], fr_mm_s, extruder);
#endif #endif
} }
@ -525,7 +515,7 @@
static bool ubl_prepare_linear_move_to(const float ltarget[XYZE], const float &feedrate) { static bool ubl_prepare_linear_move_to(const float ltarget[XYZE], const float &feedrate) {
if ( ! position_is_reachable_xy( ltarget[X_AXIS], ltarget[Y_AXIS] )) // fail if moving outside reachable boundary if (!position_is_reachable_xy(ltarget[X_AXIS], ltarget[Y_AXIS])) // fail if moving outside reachable boundary
return true; // did not move, so current_position still accurate return true; // did not move, so current_position still accurate
const float difference[XYZE] = { // cartesian distances moved in XYZE const float difference[XYZE] = { // cartesian distances moved in XYZE
@ -533,21 +523,21 @@
ltarget[Y_AXIS] - current_position[Y_AXIS], ltarget[Y_AXIS] - current_position[Y_AXIS],
ltarget[Z_AXIS] - current_position[Z_AXIS], ltarget[Z_AXIS] - current_position[Z_AXIS],
ltarget[E_AXIS] - current_position[E_AXIS] ltarget[E_AXIS] - current_position[E_AXIS]
}; };
float cartesian_xy_mm = sqrtf( sq(difference[X_AXIS]) + sq(difference[Y_AXIS]) ); // total horizontal xy distance const float cartesian_xy_mm = HYPOT(difference[X_AXIS], difference[Y_AXIS]); // total horizontal xy distance
#if IS_KINEMATIC #if IS_KINEMATIC
float seconds = cartesian_xy_mm / feedrate; // seconds to move xy distance at requested rate const float seconds = cartesian_xy_mm / feedrate; // seconds to move xy distance at requested rate
uint16_t segments = lroundf( delta_segments_per_second * seconds ); // preferred number of segments for distance @ feedrate uint16_t segments = lroundf(delta_segments_per_second * seconds), // preferred number of segments for distance @ feedrate
uint16_t seglimit = lroundf( cartesian_xy_mm * (1.0/(DELTA_SEGMENT_MIN_LENGTH))); // number of segments at minimum segment length seglimit = lroundf(cartesian_xy_mm * (1.0 / (DELTA_SEGMENT_MIN_LENGTH))); // number of segments at minimum segment length
NOMORE( segments, seglimit ); // limit to minimum segment length (fewer segments) NOMORE(segments, seglimit); // limit to minimum segment length (fewer segments)
#else #else
uint16_t segments = lroundf( cartesian_xy_mm * (1.0/(DELTA_SEGMENT_MIN_LENGTH))); // cartesian fixed segment length uint16_t segments = lroundf(cartesian_xy_mm * (1.0 / (DELTA_SEGMENT_MIN_LENGTH))); // cartesian fixed segment length
#endif #endif
NOLESS( segments, 1 ); // must have at least one segment NOLESS(segments, 1); // must have at least one segment
float inv_segments = 1.0 / segments; // divide once, multiply thereafter const float inv_segments = 1.0 / segments; // divide once, multiply thereafter
#if IS_SCARA // scale the feed rate from mm/s to degrees/s #if IS_SCARA // scale the feed rate from mm/s to degrees/s
scara_feed_factor = cartesian_xy_mm * inv_segments * feedrate; scara_feed_factor = cartesian_xy_mm * inv_segments * feedrate;
@ -560,57 +550,53 @@
difference[Y_AXIS] * inv_segments, difference[Y_AXIS] * inv_segments,
difference[Z_AXIS] * inv_segments, difference[Z_AXIS] * inv_segments,
difference[E_AXIS] * inv_segments difference[E_AXIS] * inv_segments
}; };
// Note that E segment distance could vary slightly as z mesh height // Note that E segment distance could vary slightly as z mesh height
// changes for each segment, but small enough to ignore. // changes for each segment, but small enough to ignore.
bool above_fade_height = false; const bool above_fade_height = (
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
if (( planner.z_fade_height != 0 ) && planner.z_fade_height != 0 && planner.z_fade_height < RAW_Z_POSITION(ltarget[Z_AXIS])
( planner.z_fade_height < RAW_Z_POSITION(ltarget[Z_AXIS]) )) { #else
above_fade_height = true; false
} #endif
#endif );
// Only compute leveling per segment if ubl active and target below z_fade_height. // Only compute leveling per segment if ubl active and target below z_fade_height.
if (( ! ubl.state.active ) || ( above_fade_height )) { // no mesh leveling if (!ubl.state.active || above_fade_height) { // no mesh leveling
const float z_offset = ubl.state.active ? ubl.state.z_offset : 0.0; const float z_offset = ubl.state.active ? ubl.state.z_offset : 0.0;
float seg_dest[XYZE]; // per-segment destination, float seg_dest[XYZE]; // per-segment destination,
COPY_XYZE( seg_dest, current_position ); // starting from current position COPY(seg_dest, current_position); // starting from current position
while (--segments) { while (--segments) {
LOOP_XYZE(i) seg_dest[i] += segment_distance[i]; LOOP_XYZE(i) seg_dest[i] += segment_distance[i];
float ztemp = seg_dest[Z_AXIS]; float ztemp = seg_dest[Z_AXIS];
seg_dest[Z_AXIS] += z_offset; seg_dest[Z_AXIS] += z_offset;
ubl_buffer_line_segment( seg_dest, feedrate, active_extruder ); ubl_buffer_line_segment(seg_dest, feedrate, active_extruder);
seg_dest[Z_AXIS] = ztemp; seg_dest[Z_AXIS] = ztemp;
} }
// Since repeated adding segment_distance accumulates small errors, final move to exact destination. // Since repeated adding segment_distance accumulates small errors, final move to exact destination.
COPY_XYZE( seg_dest, ltarget ); COPY(seg_dest, ltarget);
seg_dest[Z_AXIS] += z_offset; seg_dest[Z_AXIS] += z_offset;
ubl_buffer_line_segment( seg_dest, feedrate, active_extruder ); ubl_buffer_line_segment(seg_dest, feedrate, active_extruder);
return false; // moved but did not set_current_to_destination(); return false; // moved but did not set_current_to_destination();
} }
// Otherwise perform per-segment leveling // Otherwise perform per-segment leveling
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
float fade_scaling_factor = ubl.fade_scaling_factor_for_z(ltarget[Z_AXIS]);
#endif
float seg_dest[XYZE]; // per-segment destination, initialize to first segment float seg_dest[XYZE]; // per-segment destination, initialize to first segment
LOOP_XYZE(i) seg_dest[i] = current_position[i] + segment_distance[i]; LOOP_XYZE(i) seg_dest[i] = current_position[i] + segment_distance[i];
const float& dx_seg = segment_distance[X_AXIS]; // alias for clarity const float& dx_seg = segment_distance[X_AXIS]; // alias for clarity
const float& dy_seg = segment_distance[Y_AXIS]; const float& dy_seg = segment_distance[Y_AXIS];
float rx = RAW_X_POSITION(seg_dest[X_AXIS]); // assume raw vs logical coordinates shifted but not scaled. float rx = RAW_X_POSITION(seg_dest[X_AXIS]), // assume raw vs logical coordinates shifted but not scaled.
float ry = RAW_Y_POSITION(seg_dest[Y_AXIS]); ry = RAW_Y_POSITION(seg_dest[Y_AXIS]);
do { // for each mesh cell encountered during the move do { // for each mesh cell encountered during the move
@ -621,74 +607,75 @@
// in top of loop and again re-find same adjacent cell and use it, just less efficient // in top of loop and again re-find same adjacent cell and use it, just less efficient
// for mesh inset area. // for mesh inset area.
int8_t cell_xi = (rx - (UBL_MESH_MIN_X)) * (1.0 / (MESH_X_DIST)); int8_t cell_xi = (rx - (UBL_MESH_MIN_X)) * (1.0 / (MESH_X_DIST)),
cell_xi = constrain( cell_xi, 0, (GRID_MAX_POINTS_X) - 1 ); cell_yi = (ry - (UBL_MESH_MIN_Y)) * (1.0 / (MESH_X_DIST));
int8_t cell_yi = (ry - (UBL_MESH_MIN_Y)) * (1.0 / (MESH_X_DIST)); cell_xi = constrain(cell_xi, 0, (GRID_MAX_POINTS_X) - 1);
cell_yi = constrain( cell_yi, 0, (GRID_MAX_POINTS_Y) - 1 ); cell_yi = constrain(cell_yi, 0, (GRID_MAX_POINTS_Y) - 1);
// float x0 = (UBL_MESH_MIN_X) + ((MESH_X_DIST) * cell_xi ); // lower left cell corner // float x0 = (UBL_MESH_MIN_X) + ((MESH_X_DIST) * cell_xi ); // lower left cell corner
// float y0 = (UBL_MESH_MIN_Y) + ((MESH_Y_DIST) * cell_yi ); // lower left cell corner // float y0 = (UBL_MESH_MIN_Y) + ((MESH_Y_DIST) * cell_yi ); // lower left cell corner
// float x1 = x0 + MESH_X_DIST; // upper right cell corner // float x1 = x0 + MESH_X_DIST; // upper right cell corner
// float y1 = y0 + MESH_Y_DIST; // upper right cell corner // float y1 = y0 + MESH_Y_DIST; // upper right cell corner
float x0 = pgm_read_float(&(ubl.mesh_index_to_xpos[cell_xi ])); // 64 byte table lookup avoids mul+add const float x0 = pgm_read_float(&(ubl.mesh_index_to_xpos[cell_xi ])), // 64 byte table lookup avoids mul+add
float y0 = pgm_read_float(&(ubl.mesh_index_to_ypos[cell_yi ])); // 64 byte table lookup avoids mul+add y0 = pgm_read_float(&(ubl.mesh_index_to_ypos[cell_yi ])), // 64 byte table lookup avoids mul+add
float x1 = pgm_read_float(&(ubl.mesh_index_to_xpos[cell_xi+1])); // 64 byte table lookup avoids mul+add x1 = pgm_read_float(&(ubl.mesh_index_to_xpos[cell_xi+1])), // 64 byte table lookup avoids mul+add
float y1 = pgm_read_float(&(ubl.mesh_index_to_ypos[cell_yi+1])); // 64 byte table lookup avoids mul+add y1 = pgm_read_float(&(ubl.mesh_index_to_ypos[cell_yi+1])), // 64 byte table lookup avoids mul+add
cx = rx - x0, // cell-relative x
cy = ry - y0; // cell-relative y
float cx = rx - x0; // cell-relative x float z_x0y0 = ubl.z_values[cell_xi ][cell_yi ], // z at lower left corner
float cy = ry - y0; // cell-relative y z_x1y0 = ubl.z_values[cell_xi+1][cell_yi ], // z at upper left corner
z_x0y1 = ubl.z_values[cell_xi ][cell_yi+1], // z at lower right corner
z_x1y1 = ubl.z_values[cell_xi+1][cell_yi+1]; // z at upper right corner
float z_x0y0 = ubl.z_values[cell_xi ][cell_yi ]; // z at lower left corner if (isnan(z_x0y0)) z_x0y0 = 0; // ideally activating ubl.state.active (G29 A)
float z_x1y0 = ubl.z_values[cell_xi+1][cell_yi ]; // z at upper left corner if (isnan(z_x1y0)) z_x1y0 = 0; // should refuse if any invalid mesh points
float z_x0y1 = ubl.z_values[cell_xi ][cell_yi+1]; // z at lower right corner if (isnan(z_x0y1)) z_x0y1 = 0; // in order to avoid isnan tests per cell,
float z_x1y1 = ubl.z_values[cell_xi+1][cell_yi+1]; // z at upper right corner if (isnan(z_x1y1)) z_x1y1 = 0; // thus guessing zero for undefined points
if ( isnan( z_x0y0 )) z_x0y0 = 0; // ideally activating ubl.state.active (G29 A) const float z_xmy0 = (z_x1y0 - z_x0y0) * (1.0 / (MESH_X_DIST)), // z slope per x along y0 (lower left to lower right)
if ( isnan( z_x1y0 )) z_x1y0 = 0; // should refuse if any invalid mesh points z_xmy1 = (z_x1y1 - z_x0y1) * (1.0 / (MESH_X_DIST)); // z slope per x along y1 (upper left to upper right)
if ( isnan( z_x0y1 )) z_x0y1 = 0; // in order to avoid isnan tests per cell,
if ( isnan( z_x1y1 )) z_x1y1 = 0; // thus guessing zero for undefined points
float z_xmy0 = (z_x1y0 - z_x0y0) * (1.0/MESH_X_DIST); // z slope per x along y0 (lower left to lower right) float z_cxy0 = z_x0y0 + z_xmy0 * cx; // z height along y0 at cx
float z_xmy1 = (z_x1y1 - z_x0y1) * (1.0/MESH_X_DIST); // z slope per x along y1 (upper left to upper right)
float z_cxy0 = z_x0y0 + z_xmy0 * cx; // z height along y0 at cx const float z_cxy1 = z_x0y1 + z_xmy1 * cx, // z height along y1 at cx
float z_cxy1 = z_x0y1 + z_xmy1 * cx; // z height along y1 at cx z_cxyd = z_cxy1 - z_cxy0; // z height difference along cx from y0 to y1
float z_cxyd = z_cxy1 - z_cxy0; // z height difference along cx from y0 to y1
float z_cxym = z_cxyd * (1.0/MESH_Y_DIST); // z slope per y along cx from y0 to y1 float z_cxym = z_cxyd * (1.0 / (MESH_Y_DIST)), // z slope per y along cx from y0 to y1
float z_cxcy = z_cxy0 + z_cxym * cy; // z height along cx at cy z_cxcy = z_cxy0 + z_cxym * cy; // z height along cx at cy
// As subsequent segments step through this cell, the z_cxy0 intercept will change // As subsequent segments step through this cell, the z_cxy0 intercept will change
// and the z_cxym slope will change, both as a function of cx within the cell, and // and the z_cxym slope will change, both as a function of cx within the cell, and
// each change by a constant for fixed segment lengths. // each change by a constant for fixed segment lengths.
float z_sxy0 = z_xmy0 * dx_seg; // per-segment adjustment to z_cxy0 const float z_sxy0 = z_xmy0 * dx_seg, // per-segment adjustment to z_cxy0
float z_sxym = ( z_xmy1 - z_xmy0 ) * (1.0/MESH_Y_DIST) * dx_seg; // per-segment adjustment to z_cxym z_sxym = (z_xmy1 - z_xmy0) * (1.0 / (MESH_Y_DIST)) * dx_seg; // per-segment adjustment to z_cxym
do { // for all segments within this mesh cell do { // for all segments within this mesh cell
z_cxcy += ubl.state.z_offset; z_cxcy += ubl.state.z_offset;
if ( --segments == 0 ) { // this is last segment, use ltarget for exact if (--segments == 0) { // this is last segment, use ltarget for exact
COPY_XYZE( seg_dest, ltarget ); COPY(seg_dest, ltarget);
seg_dest[Z_AXIS] += z_cxcy; seg_dest[Z_AXIS] += z_cxcy;
ubl_buffer_line_segment( seg_dest, feedrate, active_extruder ); ubl_buffer_line_segment(seg_dest, feedrate, active_extruder);
return false; // did not set_current_to_destination() return false; // did not set_current_to_destination()
} }
float z_orig = seg_dest[Z_AXIS]; // remember the pre-leveled segment z value const float z_orig = seg_dest[Z_AXIS]; // remember the pre-leveled segment z value
seg_dest[Z_AXIS] = z_orig + z_cxcy; // adjust segment z height per mesh leveling seg_dest[Z_AXIS] = z_orig + z_cxcy; // adjust segment z height per mesh leveling
ubl_buffer_line_segment( seg_dest, feedrate, active_extruder ); ubl_buffer_line_segment(seg_dest, feedrate, active_extruder);
seg_dest[Z_AXIS] = z_orig; // restore pre-leveled z before incrementing seg_dest[Z_AXIS] = z_orig; // restore pre-leveled z before incrementing
LOOP_XYZE(i) seg_dest[i] += segment_distance[i]; // adjust seg_dest for next segment LOOP_XYZE(i) seg_dest[i] += segment_distance[i]; // adjust seg_dest for next segment
cx += dx_seg; cx += dx_seg;
cy += dy_seg; cy += dy_seg;
if ( !WITHIN(cx,0,MESH_X_DIST) || !WITHIN(cy,0,MESH_Y_DIST)) { // done within this cell, break to next if (!WITHIN(cx, 0, MESH_X_DIST) || !WITHIN(cy, 0, MESH_Y_DIST)) { // done within this cell, break to next
rx = RAW_X_POSITION(seg_dest[X_AXIS]); rx = RAW_X_POSITION(seg_dest[X_AXIS]);
ry = RAW_Y_POSITION(seg_dest[Y_AXIS]); ry = RAW_Y_POSITION(seg_dest[Y_AXIS]);
break; break;

16
Marlin/ultralcd.cpp
Unescape View File

@ -1430,17 +1430,13 @@ void kill_screen(const char* lcd_msg) {
#endif #endif
// LCD probed points are from defaults // LCD probed points are from defaults
constexpr uint8_t total_probe_points = constexpr uint8_t total_probe_points = (
#if ABL_GRID #if ENABLED(AUTO_BED_LEVELING_3POINT)
(GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) 3
#elif ENABLED(AUTO_BED_LEVELING_3POINT) #elif ABL_GRID || ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(MESH_BED_LEVELING)
int(3) GRID_MAX_POINTS
#elif ENABLED(AUTO_BED_LEVELING_UBL)
(GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)
#elif ENABLED(MESH_BED_LEVELING)
(GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)
#endif #endif
; );
#if ENABLED(MESH_BED_LEVELING) #if ENABLED(MESH_BED_LEVELING)

12
buildroot/share/git/mfdoc
Unescape View File

@ -16,12 +16,6 @@ if [[ $ORG != "MarlinFirmware" || $REPO != "MarlinDocumentation" ]]; then
exit exit
fi fi
if [[ $BRANCH != "master" ]]; then
echo "Stashing changes and changing to master."
git stash
git checkout master
fi
opensite() { opensite() {
TOOL=$(which gnome-open xdg-open open | awk '{ print $1 }') TOOL=$(which gnome-open xdg-open open | awk '{ print $1 }')
URL="http://127.0.0.1:4000/" URL="http://127.0.0.1:4000/"
@ -40,9 +34,3 @@ echo "Previewing MarlinDocumentation..."
( sleep 45; opensite ) & ( sleep 45; opensite ) &
bundle exec jekyll serve --watch --incremental bundle exec jekyll serve --watch --incremental
if [[ $BRANCH != "master" ]]; then
echo "Restoring branch '$BRANCH'"
git checkout $BRANCH
git stash pop
fi

15
buildroot/share/git/mfpub
Unescape View File

@ -30,26 +30,25 @@ if [[ $BRANCH == "gh-pages" ]]; then
exit exit
fi fi
if [[ $BRANCH != "master" ]]; then echo "Stashing any changes to files..."
echo "Stashing any changes to files..." echo "Don't forget to update and push 'master'!"
echo "Don't forget to update and push 'master'!" # GOJF Card
# GOJF Card git stash
git stash
fi
COMMIT=$( git log --format="%H" -n 1 ) COMMIT=$( git log --format="%H" -n 1 )
# Clean out changes and other junk in the branch # Clean out changes and other junk in the branch
git reset --hard
git clean -d -f git clean -d -f
# Push 'master' to the fork and make a proper PR... # Push 'master' to the fork and make a proper PR...
if [[ $BRANCH == "master" ]]; then if [[ $BRANCH == "master" ]]; then
# Allow working directly with the main fork # Allow working directly with the main fork
echo
echo -n "Pushing to origin/master... " echo -n "Pushing to origin/master... "
git push -f origin git push -f origin
echo
echo -n "Pushing to upstream/master... " echo -n "Pushing to upstream/master... "
git push -f upstream git push -f upstream
@ -58,6 +57,7 @@ else
if [ -z "$(git branch -vv | grep ^\* | grep \\[origin)" ]; then if [ -z "$(git branch -vv | grep ^\* | grep \\[origin)" ]; then
firstpush firstpush
else else
echo
echo -n "Pushing to origin/$BRANCH... " echo -n "Pushing to origin/$BRANCH... "
git push -f origin git push -f origin
fi fi
@ -79,6 +79,7 @@ fi
# mv ./_plugins/jekyll-press.rb-disabled ./_plugins/jekyll-press.rb # mv ./_plugins/jekyll-press.rb-disabled ./_plugins/jekyll-press.rb
# bundle install # bundle install
echo
echo "Generating MarlinDocumentation..." echo "Generating MarlinDocumentation..."
# build the site statically and proof it # build the site statically and proof it

Write Preview
Loading…
Cancel
Save