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

Arrange G26 functions in dependency order

Browse Source
master
Scott Lahteine 7 years ago
parent e5b43d48ee
commit 3b431f2f72
5 changed files with 422 additions and 445 deletions
Show Stats Download Patch File Download Diff File

822
Marlin/G26_Mesh_Validation_Tool.cpp
Unescape View File

@ -55,7 +55,7 @@
#endif #endif
#define G26_OK false #define G26_OK false
#define G26_ERROR true #define G26_ERR true
/** /**
* G26 Mesh Validation Tool * G26 Mesh Validation Tool
@ -142,10 +142,6 @@
void prepare_move_to_destination(); void prepare_move_to_destination();
inline void sync_plan_position_e() { planner.set_e_position_mm(current_position[E_AXIS]); } inline void sync_plan_position_e() { planner.set_e_position_mm(current_position[E_AXIS]); }
inline void set_current_from_destination() { COPY(current_position, destination); } inline void set_current_from_destination() { COPY(current_position, destination); }
#if ENABLED(NEWPANEL)
void lcd_setstatusPGM(const char* const message, const int8_t level);
void chirp_at_user();
#endif
// Private functions // Private functions
@ -155,49 +151,24 @@
static bool g26_retracted = false; // Track the retracted state of the nozzle so mismatched static bool g26_retracted = false; // Track the retracted state of the nozzle so mismatched
// retracts/recovers won't result in a bad state. // retracts/recovers won't result in a bad state.
float valid_trig_angle(float);
void G26_line_to_destination(const float &feed_rate) { static float g26_extrusion_multiplier,
const float save_feedrate = feedrate_mm_s; g26_retraction_multiplier,
feedrate_mm_s = feed_rate; // use specified feed rate g26_layer_height,
prepare_move_to_destination(); // will ultimately call ubl.line_to_destination_cartesian for UBL or ubl.prepare_linear_move_to for UBL_DELTA g26_prime_length,
feedrate_mm_s = save_feedrate; // restore global feed rate g26_x_pos, g26_y_pos;
}
static bool exit_from_g26();
static bool parse_G26_parameters();
static mesh_index_pair find_closest_circle_to_print(const float&, const float&);
static bool look_for_lines_to_connect();
static bool turn_on_heaters();
static bool prime_nozzle();
static void retract_filament(const float where[XYZE]);
static void recover_filament(const float where[XYZE]);
static void print_line_from_here_to_there(const float&, const float&, const float&, const float&, const float&, const float&);
static void move_to(const float&, const float&, const float&, const float&);
#if ENABLED(NEWPANEL)
extern bool ubl_lcd_clicked();
#endif
static void move_to(const float where[XYZE], const float &de) { move_to(where[X_AXIS], where[Y_AXIS], where[Z_AXIS], de); }
static float g26_extrusion_multiplier,
g26_retraction_multiplier,
g26_nozzle,
g26_filament_diameter,
g26_prime_length,
g26_x_pos, g26_y_pos,
g26_ooze_amount,
g26_layer_height;
static int16_t g26_bed_temp, static int16_t g26_bed_temp,
g26_hotend_temp, g26_hotend_temp;
g26_repeats;
static int8_t g26_prime_flag; static int8_t g26_prime_flag;
static bool g26_continue_with_closest, g26_keep_heaters_on;
#if ENABLED(NEWPANEL) #if ENABLED(NEWPANEL)
/** /**
* Detect ubl_lcd_clicked, debounce it, and return true for cancel * Detect is_lcd_clicked, debounce it, and return true for cancel
*/ */
bool user_canceled() { bool user_canceled() {
if (!ubl_lcd_clicked()) return false; if (!is_lcd_clicked()) return false;
safe_delay(10); // Wait for click to settle safe_delay(10); // Wait for click to settle
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTRA_LCD)
@ -205,209 +176,147 @@
lcd_quick_feedback(); lcd_quick_feedback();
#endif #endif
while (!ubl_lcd_clicked()) idle(); // Wait for button release while (!is_lcd_clicked()) idle(); // Wait for button release
// If the button is suddenly pressed again, // If the button is suddenly pressed again,
// ask the user to resolve the issue // ask the user to resolve the issue
lcd_setstatusPGM(PSTR("Release button"), 99); // will never appear... lcd_setstatusPGM(PSTR("Release button"), 99); // will never appear...
while (ubl_lcd_clicked()) idle(); // unless this loop happens while (is_lcd_clicked()) idle(); // unless this loop happens
lcd_reset_status(); lcd_reset_status();
return true; return true;
} }
#endif #endif
/** #if ENABLED(NEWPANEL)
* G26: Mesh Validation Pattern generation. bool exit_from_g26() {
* lcd_setstatusPGM(PSTR("Leaving G26"), -1);
* Used to interactively edit UBL's Mesh by placing the while (is_lcd_clicked()) idle();
* nozzle in a problem area and doing a G29 P4 R command. return G26_ERR;
*/
void gcode_G26() {
SERIAL_ECHOLNPGM("G26 command started. Waiting for heater(s).");
float tmp, start_angle, end_angle;
int i, xi, yi;
mesh_index_pair location;
// Don't allow Mesh Validation without homing first,
// or if the parameter parsing did not go OK, abort
if (axis_unhomed_error() || parse_G26_parameters()) return;
if (current_position[Z_AXIS] < Z_CLEARANCE_BETWEEN_PROBES) {
do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES);
stepper.synchronize();
set_current_from_destination();
} }
#endif
if (turn_on_heaters()) goto LEAVE; void G26_line_to_destination(const float &feed_rate) {
const float save_feedrate = feedrate_mm_s;
current_position[E_AXIS] = 0.0; feedrate_mm_s = feed_rate; // use specified feed rate
sync_plan_position_e(); prepare_move_to_destination(); // will ultimately call ubl.line_to_destination_cartesian for UBL or ubl.prepare_linear_move_to for UBL_DELTA
feedrate_mm_s = save_feedrate; // restore global feed rate
if (g26_prime_flag && prime_nozzle()) goto LEAVE; }
/** void move_to(const float &x, const float &y, const float &z, const float &e_delta) {
* Bed is preheated float feed_value;
* static float last_z = -999.99;
* Nozzle is at temperature
*
* Filament is primed!
*
* It's "Show Time" !!!
*/
ZERO(circle_flags); bool has_xy_component = (x != current_position[X_AXIS] || y != current_position[Y_AXIS]); // Check if X or Y is involved in the movement.
ZERO(horizontal_mesh_line_flags);
ZERO(vertical_mesh_line_flags);
// Move nozzle to the specified height for the first layer if (z != last_z) {
set_destination_from_current(); last_z = z;
destination[Z_AXIS] = g26_layer_height; feed_value = planner.max_feedrate_mm_s[Z_AXIS]/(3.0); // Base the feed rate off of the configured Z_AXIS feed rate
move_to(destination, 0.0);
move_to(destination, g26_ooze_amount);
#if ENABLED(ULTRA_LCD) destination[X_AXIS] = current_position[X_AXIS];
lcd_external_control = true; destination[Y_AXIS] = current_position[Y_AXIS];
#endif destination[Z_AXIS] = z; // We know the last_z==z or we wouldn't be in this block of code.
destination[E_AXIS] = current_position[E_AXIS];
//debug_current_and_destination(PSTR("Starting G26 Mesh Validation Pattern.")); G26_line_to_destination(feed_value);
/** stepper.synchronize();
* Declare and generate a sin() & cos() table to be used during the circle drawing. This will lighten set_destination_from_current();
* the CPU load and make the arc drawing faster and more smooth
*/
float sin_table[360 / 30 + 1], cos_table[360 / 30 + 1];
for (i = 0; i <= 360 / 30; i++) {
cos_table[i] = SIZE_OF_INTERSECTION_CIRCLES * cos(RADIANS(valid_trig_angle(i * 30.0)));
sin_table[i] = SIZE_OF_INTERSECTION_CIRCLES * sin(RADIANS(valid_trig_angle(i * 30.0)));
} }
do { // Check if X or Y is involved in the movement.
location = g26_continue_with_closest // Yes: a 'normal' movement. No: a retract() or recover()
? find_closest_circle_to_print(current_position[X_AXIS], current_position[Y_AXIS]) feed_value = has_xy_component ? PLANNER_XY_FEEDRATE() / 10.0 : planner.max_feedrate_mm_s[E_AXIS] / 1.5;
: find_closest_circle_to_print(g26_x_pos, g26_y_pos); // Find the closest Mesh Intersection to where we are now.
if (location.x_index >= 0 && location.y_index >= 0) {
const float circle_x = _GET_MESH_X(location.x_index),
circle_y = _GET_MESH_Y(location.y_index);
// If this mesh location is outside the printable_radius, skip it.
if (!position_is_reachable(circle_x, circle_y)) continue; if (g26_debug_flag) SERIAL_ECHOLNPAIR("in move_to() feed_value for XY:", feed_value);
xi = location.x_index; // Just to shrink the next few lines and make them easier to understand destination[X_AXIS] = x;
yi = location.y_index; destination[Y_AXIS] = y;
destination[E_AXIS] += e_delta;
if (g26_debug_flag) { G26_line_to_destination(feed_value);
SERIAL_ECHOPAIR(" Doing circle at: (xi=", xi);
SERIAL_ECHOPAIR(", yi=", yi);
SERIAL_CHAR(')');
SERIAL_EOL();
}
start_angle = 0.0; // assume it is going to be a full circle stepper.synchronize();
end_angle = 360.0; set_destination_from_current();
if (xi == 0) { // Check for bottom edge }
start_angle = -90.0;
end_angle = 90.0;
if (yi == 0) // it is an edge, check for the two left corners
start_angle = 0.0;
else if (yi == GRID_MAX_POINTS_Y - 1)
end_angle = 0.0;
}
else if (xi == GRID_MAX_POINTS_X - 1) { // Check for top edge
start_angle = 90.0;
end_angle = 270.0;
if (yi == 0) // it is an edge, check for the two right corners
end_angle = 180.0;
else if (yi == GRID_MAX_POINTS_Y - 1)
start_angle = 180.0;
}
else if (yi == 0) {
start_angle = 0.0; // only do the top side of the cirlce
end_angle = 180.0;
}
else if (yi == GRID_MAX_POINTS_Y - 1) {
start_angle = 180.0; // only do the bottom side of the cirlce
end_angle = 360.0;
}
for (tmp = start_angle; tmp < end_angle - 0.1; tmp += 30.0) { FORCE_INLINE void move_to(const float where[XYZE], const float &de) { move_to(where[X_AXIS], where[Y_AXIS], where[Z_AXIS], de); }
#if ENABLED(NEWPANEL) void retract_filament(const float where[XYZE]) {
if (user_canceled()) goto LEAVE; // Check if the user wants to stop the Mesh Validation if (!g26_retracted) { // Only retract if we are not already retracted!
#endif g26_retracted = true;
move_to(where, -1.0 * g26_retraction_multiplier);
}
}
int tmp_div_30 = tmp / 30.0; void recover_filament(const float where[XYZE]) {
if (tmp_div_30 < 0) tmp_div_30 += 360 / 30; if (g26_retracted) { // Only un-retract if we are retracted.
if (tmp_div_30 > 11) tmp_div_30 -= 360 / 30; move_to(where, 1.2 * g26_retraction_multiplier);
g26_retracted = false;
}
}
float rx = circle_x + cos_table[tmp_div_30], // for speed, these are now a lookup table entry /**
ry = circle_y + sin_table[tmp_div_30], * Prime the nozzle if needed. Return true on error.
xe = circle_x + cos_table[tmp_div_30 + 1], */
ye = circle_y + sin_table[tmp_div_30 + 1]; inline bool prime_nozzle() {
#if IS_KINEMATIC
// Check to make sure this segment is entirely on the bed, skip if not.
if (!position_is_reachable(rx, ry) || !position_is_reachable(xe, ye)) continue;
#else // not, we need to skip
rx = constrain(rx, X_MIN_POS + 1, X_MAX_POS - 1); // This keeps us from bumping the endstops
ry = constrain(ry, Y_MIN_POS + 1, Y_MAX_POS - 1);
xe = constrain(xe, X_MIN_POS + 1, X_MAX_POS - 1);
ye = constrain(ye, Y_MIN_POS + 1, Y_MAX_POS - 1);
#endif
//if (g26_debug_flag) { #if ENABLED(NEWPANEL)
// char ccc, *cptr, seg_msg[50], seg_num[10]; float Total_Prime = 0.0;
// strcpy(seg_msg, " segment: ");
// strcpy(seg_num, " \n");
// cptr = (char*) "01234567890ABCDEF????????";
// ccc = cptr[tmp_div_30];
// seg_num[1] = ccc;
// strcat(seg_msg, seg_num);
// debug_current_and_destination(seg_msg);
//}
print_line_from_here_to_there(rx, ry, g26_layer_height, xe, ye, g26_layer_height); if (g26_prime_flag == -1) { // The user wants to control how much filament gets purged
} lcd_external_control = true;
if (look_for_lines_to_connect()) lcd_setstatusPGM(PSTR("User-Controlled Prime"), 99);
goto LEAVE; lcd_chirp();
}
} while (--g26_repeats && location.x_index >= 0 && location.y_index >= 0);
LEAVE: set_destination_from_current();
lcd_setstatusPGM(PSTR("Leaving G26"), -1);
retract_filament(destination); recover_filament(destination); // Make sure G26 doesn't think the filament is retracted().
destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES;
//debug_current_and_destination(PSTR("ready to do Z-Raise.")); while (!is_lcd_clicked()) {
move_to(destination, 0); // Raise the nozzle lcd_chirp();
//debug_current_and_destination(PSTR("done doing Z-Raise.")); destination[E_AXIS] += 0.25;
#ifdef PREVENT_LENGTHY_EXTRUDE
Total_Prime += 0.25;
if (Total_Prime >= EXTRUDE_MAXLENGTH) return G26_ERR;
#endif
G26_line_to_destination(planner.max_feedrate_mm_s[E_AXIS] / 15.0);
destination[X_AXIS] = g26_x_pos; // Move back to the starting position stepper.synchronize(); // Without this synchronize, the purge is more consistent,
destination[Y_AXIS] = g26_y_pos; // but because the planner has a buffer, we won't be able
//destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES; // Keep the nozzle where it is // to stop as quickly. So we put up with the less smooth
// action to give the user a more responsive 'Stop'.
set_destination_from_current();
idle();
}
move_to(destination, 0); // Move back to the starting position while (is_lcd_clicked()) idle(); // Debounce Encoder Wheel
//debug_current_and_destination(PSTR("done doing X/Y move."));
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTRA_LCD)
lcd_external_control = false; // Give back control of the LCD Panel! strcpy_P(lcd_status_message, PSTR("Done Priming")); // We can't do lcd_setstatusPGM() without having it continue;
// So... We cheat to get a message up.
lcd_setstatusPGM(PSTR("Done Priming"), 99);
lcd_quick_feedback();
lcd_external_control = false;
#endif
}
else
#endif #endif
{
if (!g26_keep_heaters_on) { #if ENABLED(ULTRA_LCD)
#if HAS_TEMP_BED lcd_setstatusPGM(PSTR("Fixed Length Prime."), 99);
thermalManager.setTargetBed(0); lcd_quick_feedback();
#endif #endif
thermalManager.setTargetHotend(0, 0); set_destination_from_current();
destination[E_AXIS] += g26_prime_length;
G26_line_to_destination(planner.max_feedrate_mm_s[E_AXIS] / 15.0);
stepper.synchronize();
set_destination_from_current();
retract_filament(destination);
} }
}
float valid_trig_angle(float d) { return G26_OK;
while (d > 360.0) d -= 360.0;
while (d < 0.0) d += 360.0;
return d;
} }
mesh_index_pair find_closest_circle_to_print(const float &X, const float &Y) { mesh_index_pair find_closest_circle_to_print(const float &X, const float &Y) {
@ -448,7 +357,55 @@
return return_val; return return_val;
} }
bool look_for_lines_to_connect() { /**
* print_line_from_here_to_there() takes two cartesian coordinates and draws a line from one
* to the other. But there are really three sets of coordinates involved. The first coordinate
* is the present location of the nozzle. We don't necessarily want to print from this location.
* We first need to move the nozzle to the start of line segment where we want to print. Once
* there, we can use the two coordinates supplied to draw the line.
*
* Note: Although we assume the first set of coordinates is the start of the line and the second
* set of coordinates is the end of the line, it does not always work out that way. This function
* optimizes the movement to minimize the travel distance before it can start printing. This saves
* a lot of time and eliminates a lot of nonsensical movement of the nozzle. However, it does
* cause a lot of very little short retracement of th nozzle when it draws the very first line
* segment of a 'circle'. The time this requires is very short and is easily saved by the other
* cases where the optimization comes into play.
*/
void print_line_from_here_to_there(const float &sx, const float &sy, const float &sz, const float &ex, const float &ey, const float &ez) {
const float dx_s = current_position[X_AXIS] - sx, // find our distance from the start of the actual line segment
dy_s = current_position[Y_AXIS] - sy,
dist_start = HYPOT2(dx_s, dy_s), // We don't need to do a sqrt(), we can compare the distance^2
// to save computation time
dx_e = current_position[X_AXIS] - ex, // find our distance from the end of the actual line segment
dy_e = current_position[Y_AXIS] - ey,
dist_end = HYPOT2(dx_e, dy_e),
line_length = HYPOT(ex - sx, ey - sy);
// If the end point of the line is closer to the nozzle, flip the direction,
// moving from the end to the start. On very small lines the optimization isn't worth it.
if (dist_end < dist_start && (SIZE_OF_INTERSECTION_CIRCLES) < FABS(line_length))
return print_line_from_here_to_there(ex, ey, ez, sx, sy, sz);
// Decide whether to retract & bump
if (dist_start > 2.0) {
retract_filament(destination);
//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(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
const float e_pos_delta = line_length * g26_e_axis_feedrate * g26_extrusion_multiplier;
recover_filament(destination);
move_to(ex, ey, ez, e_pos_delta); // Get to the ending point with an appropriate amount of extrusion
}
inline bool look_for_lines_to_connect() {
float sx, sy, ex, ey; float sx, sy, ex, ey;
for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) { for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) {
@ -534,132 +491,106 @@
return false; return false;
} }
void move_to(const float &x, const float &y, const float &z, const float &e_delta) { float valid_trig_angle(float d) {
float feed_value; while (d > 360.0) d -= 360.0;
static float last_z = -999.99; while (d < 0.0) d += 360.0;
return d;
bool has_xy_component = (x != current_position[X_AXIS] || y != current_position[Y_AXIS]); // Check if X or Y is involved in the movement.
if (z != last_z) {
last_z = z;
feed_value = planner.max_feedrate_mm_s[Z_AXIS]/(3.0); // Base the feed rate off of the configured Z_AXIS feed rate
destination[X_AXIS] = current_position[X_AXIS];
destination[Y_AXIS] = current_position[Y_AXIS];
destination[Z_AXIS] = z; // We know the last_z==z or we wouldn't be in this block of code.
destination[E_AXIS] = current_position[E_AXIS];
G26_line_to_destination(feed_value);
stepper.synchronize();
set_destination_from_current();
}
// Check if X or Y is involved in the movement.
// Yes: a 'normal' movement. No: a retract() or recover()
feed_value = has_xy_component ? PLANNER_XY_FEEDRATE() / 10.0 : planner.max_feedrate_mm_s[E_AXIS] / 1.5;
if (g26_debug_flag) SERIAL_ECHOLNPAIR("in move_to() feed_value for XY:", feed_value);
destination[X_AXIS] = x;
destination[Y_AXIS] = y;
destination[E_AXIS] += e_delta;
G26_line_to_destination(feed_value);
stepper.synchronize();
set_destination_from_current();
}
void retract_filament(const float where[XYZE]) {
if (!g26_retracted) { // Only retract if we are not already retracted!
g26_retracted = true;
move_to(where, -1.0 * g26_retraction_multiplier);
}
}
void recover_filament(const float where[XYZE]) {
if (g26_retracted) { // Only un-retract if we are retracted.
move_to(where, 1.2 * g26_retraction_multiplier);
g26_retracted = false;
}
} }
/** /**
* print_line_from_here_to_there() takes two cartesian coordinates and draws a line from one * Turn on the bed and nozzle heat and
* to the other. But there are really three sets of coordinates involved. The first coordinate * wait for them to get up to temperature.
* is the present location of the nozzle. We don't necessarily want to print from this location.
* We first need to move the nozzle to the start of line segment where we want to print. Once
* there, we can use the two coordinates supplied to draw the line.
*
* Note: Although we assume the first set of coordinates is the start of the line and the second
* set of coordinates is the end of the line, it does not always work out that way. This function
* optimizes the movement to minimize the travel distance before it can start printing. This saves
* a lot of time and eliminates a lot of nonsensical movement of the nozzle. However, it does
* cause a lot of very little short retracement of th nozzle when it draws the very first line
* segment of a 'circle'. The time this requires is very short and is easily saved by the other
* cases where the optimization comes into play.
*/ */
void print_line_from_here_to_there(const float &sx, const float &sy, const float &sz, const float &ex, const float &ey, const float &ez) { bool turn_on_heaters() {
const float dx_s = current_position[X_AXIS] - sx, // find our distance from the start of the actual line segment millis_t next = millis() + 5000UL;
dy_s = current_position[Y_AXIS] - sy, #if HAS_TEMP_BED
dist_start = HYPOT2(dx_s, dy_s), // We don't need to do a sqrt(), we can compare the distance^2 #if ENABLED(ULTRA_LCD)
// to save computation time if (g26_bed_temp > 25) {
dx_e = current_position[X_AXIS] - ex, // find our distance from the end of the actual line segment lcd_setstatusPGM(PSTR("G26 Heating Bed."), 99);
dy_e = current_position[Y_AXIS] - ey, lcd_quick_feedback();
dist_end = HYPOT2(dx_e, dy_e), lcd_external_control = true;
#endif
thermalManager.setTargetBed(g26_bed_temp);
while (abs(thermalManager.degBed() - g26_bed_temp) > 3) {
line_length = HYPOT(ex - sx, ey - sy); #if ENABLED(NEWPANEL)
if (is_lcd_clicked()) return exit_from_g26();
#endif
// If the end point of the line is closer to the nozzle, flip the direction, if (ELAPSED(millis(), next)) {
// moving from the end to the start. On very small lines the optimization isn't worth it. next = millis() + 5000UL;
if (dist_end < dist_start && (SIZE_OF_INTERSECTION_CIRCLES) < FABS(line_length)) print_heaterstates();
return print_line_from_here_to_there(ex, ey, ez, sx, sy, sz); SERIAL_EOL();
}
idle();
}
#if ENABLED(ULTRA_LCD)
}
lcd_setstatusPGM(PSTR("G26 Heating Nozzle."), 99);
lcd_quick_feedback();
#endif
#endif
// Decide whether to retract & bump // Start heating the nozzle and wait for it to reach temperature.
thermalManager.setTargetHotend(g26_hotend_temp, 0);
while (abs(thermalManager.degHotend(0) - g26_hotend_temp) > 3) {
if (dist_start > 2.0) { #if ENABLED(NEWPANEL)
retract_filament(destination); if (is_lcd_clicked()) return exit_from_g26();
//todo: parameterize the bump height with a define #endif
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.0); // Get to the starting point with no extrusion / un-Z bump if (ELAPSED(millis(), next)) {
next = millis() + 5000UL;
print_heaterstates();
SERIAL_EOL();
}
idle();
}
const float e_pos_delta = line_length * g26_e_axis_feedrate * g26_extrusion_multiplier; #if ENABLED(ULTRA_LCD)
lcd_reset_status();
lcd_quick_feedback();
#endif
recover_filament(destination); return G26_OK;
move_to(ex, ey, ez, e_pos_delta); // Get to the ending point with an appropriate amount of extrusion
} }
/** /**
* This function used to be inline code in G26. But there are so many * G26: Mesh Validation Pattern generation.
* parameters it made sense to turn them into static globals and get *
* this code out of sight of the main routine. * Used to interactively edit UBL's Mesh by placing the
* nozzle in a problem area and doing a G29 P4 R command.
*/ */
bool parse_G26_parameters() { void gcode_G26() {
SERIAL_ECHOLNPGM("G26 command started. Waiting for heater(s).");
g26_extrusion_multiplier = EXTRUSION_MULTIPLIER; float tmp, start_angle, end_angle;
g26_retraction_multiplier = RETRACTION_MULTIPLIER; int i, xi, yi;
g26_nozzle = MESH_TEST_NOZZLE_SIZE; mesh_index_pair location;
g26_filament_diameter = DEFAULT_NOMINAL_FILAMENT_DIA;
g26_layer_height = MESH_TEST_LAYER_HEIGHT; // Don't allow Mesh Validation without homing first,
g26_prime_length = PRIME_LENGTH; // or if the parameter parsing did not go OK, abort
g26_bed_temp = MESH_TEST_BED_TEMP; if (axis_unhomed_error()) return;
g26_hotend_temp = MESH_TEST_HOTEND_TEMP;
g26_prime_flag = 0; g26_extrusion_multiplier = EXTRUSION_MULTIPLIER;
g26_retraction_multiplier = RETRACTION_MULTIPLIER;
g26_ooze_amount = parser.linearval('O', OOZE_AMOUNT); g26_layer_height = MESH_TEST_LAYER_HEIGHT;
g26_keep_heaters_on = parser.boolval('K'); g26_prime_length = PRIME_LENGTH;
g26_continue_with_closest = parser.boolval('C'); g26_bed_temp = MESH_TEST_BED_TEMP;
g26_hotend_temp = MESH_TEST_HOTEND_TEMP;
g26_prime_flag = 0;
float g26_nozzle = MESH_TEST_NOZZLE_SIZE,
g26_filament_diameter = DEFAULT_NOMINAL_FILAMENT_DIA,
g26_ooze_amount = parser.linearval('O', OOZE_AMOUNT);
bool g26_continue_with_closest = parser.boolval('C'),
g26_keep_heaters_on = parser.boolval('K');
if (parser.seenval('B')) { if (parser.seenval('B')) {
g26_bed_temp = parser.value_celsius(); g26_bed_temp = parser.value_celsius();
if (!WITHIN(g26_bed_temp, 15, 140)) { if (!WITHIN(g26_bed_temp, 15, 140)) {
SERIAL_PROTOCOLLNPGM("?Specified bed temperature not plausible."); SERIAL_PROTOCOLLNPGM("?Specified bed temperature not plausible.");
return G26_ERROR; return G26_ERR;
} }
} }
@ -667,7 +598,7 @@
g26_layer_height = parser.value_linear_units(); g26_layer_height = parser.value_linear_units();
if (!WITHIN(g26_layer_height, 0.0, 2.0)) { if (!WITHIN(g26_layer_height, 0.0, 2.0)) {
SERIAL_PROTOCOLLNPGM("?Specified layer height not plausible."); SERIAL_PROTOCOLLNPGM("?Specified layer height not plausible.");
return G26_ERROR; return G26_ERR;
} }
} }
@ -676,12 +607,12 @@
g26_retraction_multiplier = parser.value_float(); g26_retraction_multiplier = parser.value_float();
if (!WITHIN(g26_retraction_multiplier, 0.05, 15.0)) { if (!WITHIN(g26_retraction_multiplier, 0.05, 15.0)) {
SERIAL_PROTOCOLLNPGM("?Specified Retraction Multiplier not plausible."); SERIAL_PROTOCOLLNPGM("?Specified Retraction Multiplier not plausible.");
return G26_ERROR; return G26_ERR;
} }
} }
else { else {
SERIAL_PROTOCOLLNPGM("?Retraction Multiplier must be specified."); SERIAL_PROTOCOLLNPGM("?Retraction Multiplier must be specified.");
return G26_ERROR; return G26_ERR;
} }
} }
@ -689,7 +620,7 @@
g26_nozzle = parser.value_float(); g26_nozzle = parser.value_float();
if (!WITHIN(g26_nozzle, 0.1, 1.0)) { if (!WITHIN(g26_nozzle, 0.1, 1.0)) {
SERIAL_PROTOCOLLNPGM("?Specified nozzle size not plausible."); SERIAL_PROTOCOLLNPGM("?Specified nozzle size not plausible.");
return G26_ERROR; return G26_ERR;
} }
} }
@ -699,7 +630,7 @@
g26_prime_flag = -1; g26_prime_flag = -1;
#else #else
SERIAL_PROTOCOLLNPGM("?Prime length must be specified when not using an LCD."); SERIAL_PROTOCOLLNPGM("?Prime length must be specified when not using an LCD.");
return G26_ERROR; return G26_ERR;
#endif #endif
} }
else { else {
@ -707,7 +638,7 @@
g26_prime_length = parser.value_linear_units(); g26_prime_length = parser.value_linear_units();
if (!WITHIN(g26_prime_length, 0.0, 25.0)) { if (!WITHIN(g26_prime_length, 0.0, 25.0)) {
SERIAL_PROTOCOLLNPGM("?Specified prime length not plausible."); SERIAL_PROTOCOLLNPGM("?Specified prime length not plausible.");
return G26_ERROR; return G26_ERR;
} }
} }
} }
@ -716,7 +647,7 @@
g26_filament_diameter = parser.value_linear_units(); g26_filament_diameter = parser.value_linear_units();
if (!WITHIN(g26_filament_diameter, 1.0, 4.0)) { if (!WITHIN(g26_filament_diameter, 1.0, 4.0)) {
SERIAL_PROTOCOLLNPGM("?Specified filament size not plausible."); SERIAL_PROTOCOLLNPGM("?Specified filament size not plausible.");
return G26_ERROR; return G26_ERR;
} }
} }
g26_extrusion_multiplier *= sq(1.75) / sq(g26_filament_diameter); // If we aren't using 1.75mm filament, we need to g26_extrusion_multiplier *= sq(1.75) / sq(g26_filament_diameter); // If we aren't using 1.75mm filament, we need to
@ -729,7 +660,7 @@
g26_hotend_temp = parser.value_celsius(); g26_hotend_temp = parser.value_celsius();
if (!WITHIN(g26_hotend_temp, 165, 280)) { if (!WITHIN(g26_hotend_temp, 165, 280)) {
SERIAL_PROTOCOLLNPGM("?Specified nozzle temperature not plausible."); SERIAL_PROTOCOLLNPGM("?Specified nozzle temperature not plausible.");
return G26_ERROR; return G26_ERR;
} }
} }
@ -739,26 +670,27 @@
random_deviation = parser.has_value() ? parser.value_float() : 50.0; random_deviation = parser.has_value() ? parser.value_float() : 50.0;
} }
int16_t g26_repeats;
#if ENABLED(NEWPANEL) #if ENABLED(NEWPANEL)
g26_repeats = parser.intval('R', GRID_MAX_POINTS + 1); g26_repeats = parser.intval('R', GRID_MAX_POINTS + 1);
#else #else
if (!parser.seen('R')) { if (!parser.seen('R')) {
SERIAL_PROTOCOLLNPGM("?(R)epeat must be specified when not using an LCD."); SERIAL_PROTOCOLLNPGM("?(R)epeat must be specified when not using an LCD.");
return G26_ERROR; return G26_ERR;
} }
else else
g26_repeats = parser.has_value() ? parser.value_int() : GRID_MAX_POINTS + 1; g26_repeats = parser.has_value() ? parser.value_int() : GRID_MAX_POINTS + 1;
#endif #endif
if (g26_repeats < 1) { if (g26_repeats < 1) {
SERIAL_PROTOCOLLNPGM("?(R)epeat value not plausible; must be at least 1."); SERIAL_PROTOCOLLNPGM("?(R)epeat value not plausible; must be at least 1.");
return G26_ERROR; return G26_ERR;
} }
g26_x_pos = parser.seenval('X') ? RAW_X_POSITION(parser.value_linear_units()) : current_position[X_AXIS]; g26_x_pos = parser.seenval('X') ? RAW_X_POSITION(parser.value_linear_units()) : current_position[X_AXIS];
g26_y_pos = parser.seenval('Y') ? RAW_Y_POSITION(parser.value_linear_units()) : current_position[Y_AXIS]; g26_y_pos = parser.seenval('Y') ? RAW_Y_POSITION(parser.value_linear_units()) : current_position[Y_AXIS];
if (!position_is_reachable(g26_x_pos, g26_y_pos)) { if (!position_is_reachable(g26_x_pos, g26_y_pos)) {
SERIAL_PROTOCOLLNPGM("?Specified X,Y coordinate out of bounds."); SERIAL_PROTOCOLLNPGM("?Specified X,Y coordinate out of bounds.");
return G26_ERROR; return G26_ERR;
} }
/** /**
@ -766,137 +698,175 @@
*/ */
set_bed_leveling_enabled(!parser.seen('D')); set_bed_leveling_enabled(!parser.seen('D'));
return G26_OK; if (current_position[Z_AXIS] < Z_CLEARANCE_BETWEEN_PROBES) {
} do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES);
stepper.synchronize();
#if ENABLED(NEWPANEL) set_current_from_destination();
bool exit_from_g26() {
lcd_setstatusPGM(PSTR("Leaving G26"), -1);
while (ubl_lcd_clicked()) idle();
return G26_ERROR;
} }
#endif
/** if (turn_on_heaters()) goto LEAVE;
* Turn on the bed and nozzle heat and
* wait for them to get up to temperature.
*/
bool turn_on_heaters() {
millis_t next = millis() + 5000UL;
#if HAS_TEMP_BED
#if ENABLED(ULTRA_LCD)
if (g26_bed_temp > 25) {
lcd_setstatusPGM(PSTR("G26 Heating Bed."), 99);
lcd_quick_feedback();
lcd_external_control = true;
#endif
thermalManager.setTargetBed(g26_bed_temp);
while (abs(thermalManager.degBed() - g26_bed_temp) > 3) {
#if ENABLED(NEWPANEL) current_position[E_AXIS] = 0.0;
if (ubl_lcd_clicked()) return exit_from_g26(); sync_plan_position_e();
#endif
if (ELAPSED(millis(), next)) { if (g26_prime_flag && prime_nozzle()) goto LEAVE;
next = millis() + 5000UL;
print_heaterstates();
SERIAL_EOL();
}
idle();
}
#if ENABLED(ULTRA_LCD)
}
lcd_setstatusPGM(PSTR("G26 Heating Nozzle."), 99);
lcd_quick_feedback();
#endif
#endif
// Start heating the nozzle and wait for it to reach temperature. /**
thermalManager.setTargetHotend(g26_hotend_temp, 0); * Bed is preheated
while (abs(thermalManager.degHotend(0) - g26_hotend_temp) > 3) { *
* Nozzle is at temperature
*
* Filament is primed!
*
* It's "Show Time" !!!
*/
#if ENABLED(NEWPANEL) ZERO(circle_flags);
if (ubl_lcd_clicked()) return exit_from_g26(); ZERO(horizontal_mesh_line_flags);
#endif ZERO(vertical_mesh_line_flags);
if (ELAPSED(millis(), next)) { // Move nozzle to the specified height for the first layer
next = millis() + 5000UL; set_destination_from_current();
print_heaterstates(); destination[Z_AXIS] = g26_layer_height;
SERIAL_EOL(); move_to(destination, 0.0);
} move_to(destination, g26_ooze_amount);
idle();
}
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTRA_LCD)
lcd_reset_status(); lcd_external_control = true;
lcd_quick_feedback();
#endif #endif
return G26_OK; //debug_current_and_destination(PSTR("Starting G26 Mesh Validation Pattern."));
}
/** /**
* Prime the nozzle if needed. Return true on error. * Declare and generate a sin() & cos() table to be used during the circle drawing. This will lighten
*/ * the CPU load and make the arc drawing faster and more smooth
bool prime_nozzle() { */
float sin_table[360 / 30 + 1], cos_table[360 / 30 + 1];
for (i = 0; i <= 360 / 30; i++) {
cos_table[i] = SIZE_OF_INTERSECTION_CIRCLES * cos(RADIANS(valid_trig_angle(i * 30.0)));
sin_table[i] = SIZE_OF_INTERSECTION_CIRCLES * sin(RADIANS(valid_trig_angle(i * 30.0)));
}
#if ENABLED(NEWPANEL) do {
float Total_Prime = 0.0; location = g26_continue_with_closest
? find_closest_circle_to_print(current_position[X_AXIS], current_position[Y_AXIS])
: find_closest_circle_to_print(g26_x_pos, g26_y_pos); // Find the closest Mesh Intersection to where we are now.
if (g26_prime_flag == -1) { // The user wants to control how much filament gets purged if (location.x_index >= 0 && location.y_index >= 0) {
const float circle_x = _GET_MESH_X(location.x_index),
circle_y = _GET_MESH_Y(location.y_index);
lcd_external_control = true; // If this mesh location is outside the printable_radius, skip it.
lcd_setstatusPGM(PSTR("User-Controlled Prime"), 99);
chirp_at_user();
set_destination_from_current(); if (!position_is_reachable(circle_x, circle_y)) continue;
recover_filament(destination); // Make sure G26 doesn't think the filament is retracted(). xi = location.x_index; // Just to shrink the next few lines and make them easier to understand
yi = location.y_index;
while (!ubl_lcd_clicked()) { if (g26_debug_flag) {
chirp_at_user(); SERIAL_ECHOPAIR(" Doing circle at: (xi=", xi);
destination[E_AXIS] += 0.25; SERIAL_ECHOPAIR(", yi=", yi);
#ifdef PREVENT_LENGTHY_EXTRUDE SERIAL_CHAR(')');
Total_Prime += 0.25; SERIAL_EOL();
if (Total_Prime >= EXTRUDE_MAXLENGTH) return G26_ERROR; }
#endif
G26_line_to_destination(planner.max_feedrate_mm_s[E_AXIS] / 15.0);
stepper.synchronize(); // Without this synchronize, the purge is more consistent, start_angle = 0.0; // assume it is going to be a full circle
// but because the planner has a buffer, we won't be able end_angle = 360.0;
// to stop as quickly. So we put up with the less smooth if (xi == 0) { // Check for bottom edge
// action to give the user a more responsive 'Stop'. start_angle = -90.0;
set_destination_from_current(); end_angle = 90.0;
idle(); if (yi == 0) // it is an edge, check for the two left corners
start_angle = 0.0;
else if (yi == GRID_MAX_POINTS_Y - 1)
end_angle = 0.0;
}
else if (xi == GRID_MAX_POINTS_X - 1) { // Check for top edge
start_angle = 90.0;
end_angle = 270.0;
if (yi == 0) // it is an edge, check for the two right corners
end_angle = 180.0;
else if (yi == GRID_MAX_POINTS_Y - 1)
start_angle = 180.0;
}
else if (yi == 0) {
start_angle = 0.0; // only do the top side of the cirlce
end_angle = 180.0;
}
else if (yi == GRID_MAX_POINTS_Y - 1) {
start_angle = 180.0; // only do the bottom side of the cirlce
end_angle = 360.0;
} }
while (ubl_lcd_clicked()) idle(); // Debounce Encoder Wheel for (tmp = start_angle; tmp < end_angle - 0.1; tmp += 30.0) {
#if ENABLED(ULTRA_LCD) #if ENABLED(NEWPANEL)
strcpy_P(lcd_status_message, PSTR("Done Priming")); // We can't do lcd_setstatusPGM() without having it continue; if (user_canceled()) goto LEAVE; // Check if the user wants to stop the Mesh Validation
// So... We cheat to get a message up. #endif
lcd_setstatusPGM(PSTR("Done Priming"), 99);
lcd_quick_feedback(); int tmp_div_30 = tmp / 30.0;
lcd_external_control = false; if (tmp_div_30 < 0) tmp_div_30 += 360 / 30;
#endif if (tmp_div_30 > 11) tmp_div_30 -= 360 / 30;
float rx = circle_x + cos_table[tmp_div_30], // for speed, these are now a lookup table entry
ry = circle_y + sin_table[tmp_div_30],
xe = circle_x + cos_table[tmp_div_30 + 1],
ye = circle_y + sin_table[tmp_div_30 + 1];
#if IS_KINEMATIC
// Check to make sure this segment is entirely on the bed, skip if not.
if (!position_is_reachable(rx, ry) || !position_is_reachable(xe, ye)) continue;
#else // not, we need to skip
rx = constrain(rx, X_MIN_POS + 1, X_MAX_POS - 1); // This keeps us from bumping the endstops
ry = constrain(ry, Y_MIN_POS + 1, Y_MAX_POS - 1);
xe = constrain(xe, X_MIN_POS + 1, X_MAX_POS - 1);
ye = constrain(ye, Y_MIN_POS + 1, Y_MAX_POS - 1);
#endif
//if (g26_debug_flag) {
// char ccc, *cptr, seg_msg[50], seg_num[10];
// strcpy(seg_msg, " segment: ");
// strcpy(seg_num, " \n");
// cptr = (char*) "01234567890ABCDEF????????";
// ccc = cptr[tmp_div_30];
// seg_num[1] = ccc;
// strcat(seg_msg, seg_num);
// debug_current_and_destination(seg_msg);
//}
print_line_from_here_to_there(rx, ry, g26_layer_height, xe, ye, g26_layer_height);
}
if (look_for_lines_to_connect())
goto LEAVE;
} }
else { } while (--g26_repeats && location.x_index >= 0 && location.y_index >= 0);
#else
{ LEAVE:
lcd_setstatusPGM(PSTR("Leaving G26"), -1);
retract_filament(destination);
destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES;
//debug_current_and_destination(PSTR("ready to do Z-Raise."));
move_to(destination, 0); // Raise the nozzle
//debug_current_and_destination(PSTR("done doing Z-Raise."));
destination[X_AXIS] = g26_x_pos; // Move back to the starting position
destination[Y_AXIS] = g26_y_pos;
//destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES; // Keep the nozzle where it is
move_to(destination, 0); // Move back to the starting position
//debug_current_and_destination(PSTR("done doing X/Y move."));
#if ENABLED(ULTRA_LCD)
lcd_external_control = false; // Give back control of the LCD Panel!
#endif #endif
#if ENABLED(ULTRA_LCD)
lcd_setstatusPGM(PSTR("Fixed Length Prime."), 99); if (!g26_keep_heaters_on) {
lcd_quick_feedback(); #if HAS_TEMP_BED
thermalManager.setTargetBed(0);
#endif #endif
set_destination_from_current(); thermalManager.setTargetHotend(0, 0);
destination[E_AXIS] += g26_prime_length;
G26_line_to_destination(planner.max_feedrate_mm_s[E_AXIS] / 15.0);
stepper.synchronize();
set_destination_from_current();
retract_filament(destination);
} }
return G26_OK;
} }
#endif // G26_MESH_VALIDATION #endif // G26_MESH_VALIDATION

1
Marlin/ubl.h
Unescape View File

@ -50,7 +50,6 @@
// External references // External references
char *ftostr43sign(const float&, char); char *ftostr43sign(const float&, char);
bool ubl_lcd_clicked();
void home_all_axes(); void home_all_axes();
extern uint8_t ubl_cnt; extern uint8_t ubl_cnt;

28
Marlin/ubl_G29.cpp
Unescape View File

@ -47,7 +47,6 @@
float lcd_mesh_edit(); float lcd_mesh_edit();
void lcd_z_offset_edit_setup(float); void lcd_z_offset_edit_setup(float);
extern void _lcd_ubl_output_map_lcd(); extern void _lcd_ubl_output_map_lcd();
extern bool ubl_lcd_clicked();
float lcd_z_offset_edit(); float lcd_z_offset_edit();
#endif #endif
@ -750,11 +749,11 @@
if (do_ubl_mesh_map) display_map(g29_map_type); if (do_ubl_mesh_map) display_map(g29_map_type);
#if ENABLED(NEWPANEL) #if ENABLED(NEWPANEL)
if (ubl_lcd_clicked()) { if (is_lcd_clicked()) {
SERIAL_PROTOCOLLNPGM("\nMesh only partially populated.\n"); SERIAL_PROTOCOLLNPGM("\nMesh only partially populated.\n");
lcd_quick_feedback(); lcd_quick_feedback();
STOW_PROBE(); STOW_PROBE();
while (ubl_lcd_clicked()) idle(); while (is_lcd_clicked()) idle();
lcd_external_control = false; lcd_external_control = false;
restore_ubl_active_state_and_leave(); restore_ubl_active_state_and_leave();
safe_delay(50); // Debounce the Encoder wheel safe_delay(50); // Debounce the Encoder wheel
@ -893,13 +892,14 @@
#endif // HAS_BED_PROBE #endif // HAS_BED_PROBE
#if ENABLED(NEWPANEL) #if ENABLED(NEWPANEL)
float unified_bed_leveling::measure_point_with_encoder() { float unified_bed_leveling::measure_point_with_encoder() {
while (ubl_lcd_clicked()) delay(50); // wait for user to release encoder wheel while (is_lcd_clicked()) delay(50); // wait for user to release encoder wheel
delay(50); // debounce delay(50); // debounce
KEEPALIVE_STATE(PAUSED_FOR_USER); KEEPALIVE_STATE(PAUSED_FOR_USER);
while (!ubl_lcd_clicked()) { // we need the loop to move the nozzle based on the encoder wheel here! while (!is_lcd_clicked()) { // we need the loop to move the nozzle based on the encoder wheel here!
idle(); idle();
if (encoder_diff) { if (encoder_diff) {
do_blocking_move_to_z(current_position[Z_AXIS] + 0.01 * float(encoder_diff)); do_blocking_move_to_z(current_position[Z_AXIS] + 0.01 * float(encoder_diff));
@ -989,9 +989,9 @@
const float z_step = 0.01; // existing behavior: 0.01mm per click, occasionally step const float z_step = 0.01; // existing behavior: 0.01mm per click, occasionally step
//const float z_step = 1.0 / planner.axis_steps_per_mm[Z_AXIS]; // approx one step each click //const float z_step = 1.0 / planner.axis_steps_per_mm[Z_AXIS]; // approx one step each click
while (ubl_lcd_clicked()) delay(50); // wait for user to release encoder wheel while (is_lcd_clicked()) delay(50); // wait for user to release encoder wheel
delay(50); // debounce delay(50); // debounce
while (!ubl_lcd_clicked()) { // we need the loop to move the nozzle based on the encoder wheel here! while (!is_lcd_clicked()) { // we need the loop to move the nozzle based on the encoder wheel here!
idle(); idle();
if (encoder_diff) { if (encoder_diff) {
do_blocking_move_to_z(current_position[Z_AXIS] + float(encoder_diff) * z_step); do_blocking_move_to_z(current_position[Z_AXIS] + float(encoder_diff) * z_step);
@ -999,11 +999,11 @@
} }
} }
// this sequence to detect an ubl_lcd_clicked() debounce it and leave if it is // this sequence to detect an is_lcd_clicked() debounce it and leave if it is
// a Press and Hold is repeated in a lot of places (including G26_Mesh_Validation.cpp). This // a Press and Hold is repeated in a lot of places (including G26_Mesh_Validation.cpp). This
// should be redone and compressed. // should be redone and compressed.
const millis_t nxt = millis() + 1500L; const millis_t nxt = millis() + 1500L;
while (ubl_lcd_clicked()) { // debounce and watch for abort while (is_lcd_clicked()) { // debounce and watch for abort
idle(); idle();
if (ELAPSED(millis(), nxt)) { if (ELAPSED(millis(), nxt)) {
SERIAL_PROTOCOLLNPGM("\nMesh only partially populated."); SERIAL_PROTOCOLLNPGM("\nMesh only partially populated.");
@ -1011,7 +1011,7 @@
#if ENABLED(NEWPANEL) #if ENABLED(NEWPANEL)
lcd_quick_feedback(); lcd_quick_feedback();
while (ubl_lcd_clicked()) idle(); while (is_lcd_clicked()) idle();
lcd_external_control = false; lcd_external_control = false;
#endif #endif
@ -1528,7 +1528,7 @@
do_blocking_move_to_z(h_offset + new_z); // Move the nozzle as the point is edited do_blocking_move_to_z(h_offset + new_z); // Move the nozzle as the point is edited
#endif #endif
idle(); idle();
} while (!ubl_lcd_clicked()); } while (!is_lcd_clicked());
if (!lcd_map_control) lcd_return_to_status(); if (!lcd_map_control) lcd_return_to_status();
@ -1537,18 +1537,18 @@
// Let's work on specifying a proper API for the LCD ASAP, OK? // Let's work on specifying a proper API for the LCD ASAP, OK?
lcd_external_control = true; lcd_external_control = true;
// this sequence to detect an ubl_lcd_clicked() debounce it and leave if it is // this sequence to detect an is_lcd_clicked() debounce it and leave if it is
// a Press and Hold is repeated in a lot of places (including G26_Mesh_Validation.cpp). This // a Press and Hold is repeated in a lot of places (including G26_Mesh_Validation.cpp). This
// should be redone and compressed. // should be redone and compressed.
const millis_t nxt = millis() + 1500UL; const millis_t nxt = millis() + 1500UL;
while (ubl_lcd_clicked()) { // debounce and watch for abort while (is_lcd_clicked()) { // debounce and watch for abort
idle(); idle();
if (ELAPSED(millis(), nxt)) { if (ELAPSED(millis(), nxt)) {
lcd_return_to_status(); lcd_return_to_status();
do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES); do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES);
LCD_MESSAGEPGM(MSG_EDITING_STOPPED); LCD_MESSAGEPGM(MSG_EDITING_STOPPED);
while (ubl_lcd_clicked()) idle(); while (is_lcd_clicked()) idle();
goto FINE_TUNE_EXIT; goto FINE_TUNE_EXIT;
} }

9
Marlin/ultralcd.cpp
Unescape View File

@ -5091,17 +5091,18 @@ void lcd_reset_alert_level() { lcd_status_message_level = 0; }
bool lcd_detected() { return true; } bool lcd_detected() { return true; }
#endif #endif
#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION) #if ENABLED(G26_MESH_VALIDATION)
void chirp_at_user() { void lcd_chirp() {
#if ENABLED(LCD_USE_I2C_BUZZER) #if ENABLED(LCD_USE_I2C_BUZZER)
lcd.buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ); lcd.buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
#elif PIN_EXISTS(BEEPER) #elif PIN_EXISTS(BEEPER)
buzzer.tone(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ); buzzer.tone(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
#endif #endif
} }
#endif
bool ubl_lcd_clicked() { return LCD_CLICKED; } #if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION)
bool is_lcd_clicked() { return LCD_CLICKED; }
#endif #endif
#endif // ULTIPANEL #endif // ULTIPANEL

7
Marlin/ultralcd.h
Unescape View File

@ -29,6 +29,9 @@
#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION) #if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION)
extern bool lcd_external_control; extern bool lcd_external_control;
#if ENABLED(G26_MESH_VALIDATION)
void lcd_chirp();
#endif
#endif #endif
#define BUTTON_EXISTS(BN) (defined(BTN_## BN) && BTN_## BN >= 0) #define BUTTON_EXISTS(BN) (defined(BTN_## BN) && BTN_## BN >= 0)
@ -171,6 +174,10 @@
#define LCD_CLICKED false #define LCD_CLICKED false
#endif #endif
#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION)
bool is_lcd_clicked();
#endif
#if ENABLED(LCD_SET_PROGRESS_MANUALLY) && (ENABLED(LCD_PROGRESS_BAR) || ENABLED(DOGLCD)) #if ENABLED(LCD_SET_PROGRESS_MANUALLY) && (ENABLED(LCD_PROGRESS_BAR) || ENABLED(DOGLCD))
extern uint8_t progress_bar_percent; extern uint8_t progress_bar_percent;
#endif #endif

Write Preview
Loading…
Cancel
Save