|
|
|
@ -26,15 +26,21 @@
|
|
|
|
|
|
|
|
|
|
|
|
#include "MarlinConfig.h"
|
|
|
|
#include "MarlinConfig.h"
|
|
|
|
|
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(UBL_G26_MESH_VALIDATION)
|
|
|
|
#if ENABLED(G26_MESH_VALIDATION)
|
|
|
|
|
|
|
|
|
|
|
|
#include "ubl.h"
|
|
|
|
|
|
|
|
#include "Marlin.h"
|
|
|
|
#include "Marlin.h"
|
|
|
|
#include "planner.h"
|
|
|
|
#include "planner.h"
|
|
|
|
#include "stepper.h"
|
|
|
|
#include "stepper.h"
|
|
|
|
#include "temperature.h"
|
|
|
|
#include "temperature.h"
|
|
|
|
#include "ultralcd.h"
|
|
|
|
#include "ultralcd.h"
|
|
|
|
#include "gcode.h"
|
|
|
|
#include "gcode.h"
|
|
|
|
|
|
|
|
#include "bitmap_flags.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
|
|
|
|
|
|
|
#include "mesh_bed_leveling.h"
|
|
|
|
|
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
|
|
|
|
#include "ubl.h"
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#define EXTRUSION_MULTIPLIER 1.0
|
|
|
|
#define EXTRUSION_MULTIPLIER 1.0
|
|
|
|
#define RETRACTION_MULTIPLIER 1.0
|
|
|
|
#define RETRACTION_MULTIPLIER 1.0
|
|
|
|
@ -48,6 +54,9 @@
|
|
|
|
#error "SIZE_OF_CROSSHAIRS must be less than SIZE_OF_INTERSECTION_CIRCLES."
|
|
|
|
#error "SIZE_OF_CROSSHAIRS must be less than SIZE_OF_INTERSECTION_CIRCLES."
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define G26_OK false
|
|
|
|
|
|
|
|
#define G26_ERR true
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
/**
|
|
|
|
* G26 Mesh Validation Tool
|
|
|
|
* G26 Mesh Validation Tool
|
|
|
|
*
|
|
|
|
*
|
|
|
|
@ -133,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
|
|
|
|
|
|
|
|
|
|
|
|
@ -147,41 +152,23 @@
|
|
|
|
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);
|
|
|
|
static float g26_extrusion_multiplier,
|
|
|
|
|
|
|
|
g26_retraction_multiplier,
|
|
|
|
float unified_bed_leveling::g26_extrusion_multiplier,
|
|
|
|
g26_layer_height,
|
|
|
|
unified_bed_leveling::g26_retraction_multiplier,
|
|
|
|
g26_prime_length,
|
|
|
|
unified_bed_leveling::g26_nozzle,
|
|
|
|
g26_x_pos, g26_y_pos;
|
|
|
|
unified_bed_leveling::g26_filament_diameter,
|
|
|
|
|
|
|
|
unified_bed_leveling::g26_layer_height,
|
|
|
|
|
|
|
|
unified_bed_leveling::g26_prime_length,
|
|
|
|
|
|
|
|
unified_bed_leveling::g26_x_pos,
|
|
|
|
|
|
|
|
unified_bed_leveling::g26_y_pos,
|
|
|
|
|
|
|
|
unified_bed_leveling::g26_ooze_amount;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int16_t unified_bed_leveling::g26_bed_temp,
|
|
|
|
|
|
|
|
unified_bed_leveling::g26_hotend_temp;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int8_t unified_bed_leveling::g26_prime_flag;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool unified_bed_leveling::g26_continue_with_closest,
|
|
|
|
static int16_t g26_bed_temp,
|
|
|
|
unified_bed_leveling::g26_keep_heaters_on;
|
|
|
|
g26_hotend_temp;
|
|
|
|
|
|
|
|
|
|
|
|
int16_t unified_bed_leveling::g26_repeats;
|
|
|
|
static int8_t g26_prime_flag;
|
|
|
|
|
|
|
|
|
|
|
|
void unified_bed_leveling::G26_line_to_destination(const float &feed_rate) {
|
|
|
|
|
|
|
|
const float save_feedrate = feedrate_mm_s;
|
|
|
|
|
|
|
|
feedrate_mm_s = feed_rate; // use specified feed rate
|
|
|
|
|
|
|
|
prepare_move_to_destination(); // will ultimately call ubl.line_to_destination_cartesian or ubl.prepare_linear_move_to for UBL_DELTA
|
|
|
|
|
|
|
|
feedrate_mm_s = save_feedrate; // restore global feed rate
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#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)
|
|
|
|
@ -189,207 +176,150 @@
|
|
|
|
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 unified_bed_leveling::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) {
|
|
|
|
|
|
|
|
float feed_value;
|
|
|
|
|
|
|
|
static float last_z = -999.99;
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
bool has_xy_component = (x != current_position[X_AXIS] || y != current_position[Y_AXIS]); // Check if X or Y is involved in the movement.
|
|
|
|
* Bed is preheated
|
|
|
|
|
|
|
|
*
|
|
|
|
|
|
|
|
* Nozzle is at temperature
|
|
|
|
|
|
|
|
*
|
|
|
|
|
|
|
|
* Filament is primed!
|
|
|
|
|
|
|
|
*
|
|
|
|
|
|
|
|
* It's "Show Time" !!!
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ZERO(circle_flags);
|
|
|
|
if (z != last_z) {
|
|
|
|
ZERO(horizontal_mesh_line_flags);
|
|
|
|
last_z = z;
|
|
|
|
ZERO(vertical_mesh_line_flags);
|
|
|
|
feed_value = planner.max_feedrate_mm_s[Z_AXIS]/(3.0); // Base the feed rate off of the configured Z_AXIS feed rate
|
|
|
|
|
|
|
|
|
|
|
|
// Move nozzle to the specified height for the first layer
|
|
|
|
destination[X_AXIS] = current_position[X_AXIS];
|
|
|
|
set_destination_from_current();
|
|
|
|
destination[Y_AXIS] = current_position[Y_AXIS];
|
|
|
|
destination[Z_AXIS] = g26_layer_height;
|
|
|
|
destination[Z_AXIS] = z; // We know the last_z==z or we wouldn't be in this block of code.
|
|
|
|
move_to(destination, 0.0);
|
|
|
|
destination[E_AXIS] = current_position[E_AXIS];
|
|
|
|
move_to(destination, g26_ooze_amount);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
has_control_of_lcd_panel = true;
|
|
|
|
G26_line_to_destination(feed_value);
|
|
|
|
//debug_current_and_destination(PSTR("Starting G26 Mesh Validation Pattern."));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
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 = mesh_index_to_xpos(location.x_index),
|
|
|
|
|
|
|
|
circle_y = mesh_index_to_ypos(location.y_index);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// If this mesh location is outside the printable_radius, skip it.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (!position_is_reachable(circle_x, circle_y)) continue;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
xi = location.x_index; // Just to shrink the next few lines and make them easier to understand
|
|
|
|
if (g26_debug_flag) SERIAL_ECHOLNPAIR("in move_to() feed_value for XY:", feed_value);
|
|
|
|
yi = location.y_index;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (g26_debug_flag) {
|
|
|
|
destination[X_AXIS] = x;
|
|
|
|
SERIAL_ECHOPAIR(" Doing circle at: (xi=", xi);
|
|
|
|
destination[Y_AXIS] = y;
|
|
|
|
SERIAL_ECHOPAIR(", yi=", yi);
|
|
|
|
destination[E_AXIS] += e_delta;
|
|
|
|
SERIAL_CHAR(')');
|
|
|
|
|
|
|
|
SERIAL_EOL();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
start_angle = 0.0; // assume it is going to be a full circle
|
|
|
|
G26_line_to_destination(feed_value);
|
|
|
|
end_angle = 360.0;
|
|
|
|
|
|
|
|
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) {
|
|
|
|
stepper.synchronize();
|
|
|
|
|
|
|
|
set_destination_from_current();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#if ENABLED(NEWPANEL)
|
|
|
|
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 (user_canceled()) goto LEAVE; // Check if the user wants to stop the Mesh Validation
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int tmp_div_30 = tmp / 30.0;
|
|
|
|
void retract_filament(const float where[XYZE]) {
|
|
|
|
if (tmp_div_30 < 0) tmp_div_30 += 360 / 30;
|
|
|
|
if (!g26_retracted) { // Only retract if we are not already retracted!
|
|
|
|
if (tmp_div_30 > 11) tmp_div_30 -= 360 / 30;
|
|
|
|
g26_retracted = true;
|
|
|
|
|
|
|
|
move_to(where, -1.0 * g26_retraction_multiplier);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
float rx = circle_x + cos_table[tmp_div_30], // for speed, these are now a lookup table entry
|
|
|
|
void recover_filament(const float where[XYZE]) {
|
|
|
|
ry = circle_y + sin_table[tmp_div_30],
|
|
|
|
if (g26_retracted) { // Only un-retract if we are retracted.
|
|
|
|
xe = circle_x + cos_table[tmp_div_30 + 1],
|
|
|
|
move_to(where, 1.2 * g26_retraction_multiplier);
|
|
|
|
ye = circle_y + sin_table[tmp_div_30 + 1];
|
|
|
|
g26_retracted = false;
|
|
|
|
#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];
|
|
|
|
* Prime the nozzle if needed. Return true on error.
|
|
|
|
// strcpy(seg_msg, " segment: ");
|
|
|
|
*/
|
|
|
|
// strcpy(seg_num, " \n");
|
|
|
|
inline bool prime_nozzle() {
|
|
|
|
// 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 ENABLED(NEWPANEL)
|
|
|
|
|
|
|
|
float Total_Prime = 0.0;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
if (g26_prime_flag == -1) { // The user wants to control how much filament gets purged
|
|
|
|
if (look_for_lines_to_connect())
|
|
|
|
|
|
|
|
goto LEAVE;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} while (--g26_repeats && location.x_index >= 0 && location.y_index >= 0);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LEAVE:
|
|
|
|
lcd_external_control = true;
|
|
|
|
lcd_setstatusPGM(PSTR("Leaving G26"), -1);
|
|
|
|
lcd_setstatusPGM(PSTR("User-Controlled Prime"), 99);
|
|
|
|
|
|
|
|
lcd_chirp();
|
|
|
|
|
|
|
|
|
|
|
|
retract_filament(destination);
|
|
|
|
set_destination_from_current();
|
|
|
|
destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//debug_current_and_destination(PSTR("ready to do Z-Raise."));
|
|
|
|
recover_filament(destination); // Make sure G26 doesn't think the filament is retracted().
|
|
|
|
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
|
|
|
|
while (!is_lcd_clicked()) {
|
|
|
|
destination[Y_AXIS] = g26_y_pos;
|
|
|
|
lcd_chirp();
|
|
|
|
//destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES; // Keep the nozzle where it is
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
|
|
move_to(destination, 0); // Move back to the starting position
|
|
|
|
stepper.synchronize(); // Without this synchronize, the purge is more consistent,
|
|
|
|
//debug_current_and_destination(PSTR("done doing X/Y move."));
|
|
|
|
// but because the planner has a buffer, we won't be able
|
|
|
|
|
|
|
|
// 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();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
has_control_of_lcd_panel = false; // Give back control of the LCD Panel!
|
|
|
|
while (is_lcd_clicked()) idle(); // Debounce Encoder Wheel
|
|
|
|
|
|
|
|
|
|
|
|
if (!g26_keep_heaters_on) {
|
|
|
|
#if ENABLED(ULTRA_LCD)
|
|
|
|
#if HAS_TEMP_BED
|
|
|
|
strcpy_P(lcd_status_message, PSTR("Done Priming")); // We can't do lcd_setstatusPGM() without having it continue;
|
|
|
|
thermalManager.setTargetBed(0);
|
|
|
|
// So... We cheat to get a message up.
|
|
|
|
|
|
|
|
lcd_setstatusPGM(PSTR("Done Priming"), 99);
|
|
|
|
|
|
|
|
lcd_quick_feedback();
|
|
|
|
|
|
|
|
lcd_external_control = false;
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
else
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
{
|
|
|
|
|
|
|
|
#if ENABLED(ULTRA_LCD)
|
|
|
|
|
|
|
|
lcd_setstatusPGM(PSTR("Fixed Length Prime."), 99);
|
|
|
|
|
|
|
|
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 unified_bed_leveling::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) {
|
|
|
|
float closest = 99999.99;
|
|
|
|
float closest = 99999.99;
|
|
|
|
mesh_index_pair return_val;
|
|
|
|
mesh_index_pair return_val;
|
|
|
|
|
|
|
|
|
|
|
|
@ -398,8 +328,8 @@
|
|
|
|
for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) {
|
|
|
|
for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) {
|
|
|
|
for (uint8_t j = 0; j < GRID_MAX_POINTS_Y; j++) {
|
|
|
|
for (uint8_t j = 0; j < GRID_MAX_POINTS_Y; j++) {
|
|
|
|
if (!is_bit_set(circle_flags, i, j)) {
|
|
|
|
if (!is_bit_set(circle_flags, i, j)) {
|
|
|
|
const float mx = mesh_index_to_xpos(i), // We found a circle that needs to be printed
|
|
|
|
const float mx = _GET_MESH_X(i), // We found a circle that needs to be printed
|
|
|
|
my = mesh_index_to_ypos(j);
|
|
|
|
my = _GET_MESH_Y(j);
|
|
|
|
|
|
|
|
|
|
|
|
// Get the distance to this intersection
|
|
|
|
// Get the distance to this intersection
|
|
|
|
float f = HYPOT(X - mx, Y - my);
|
|
|
|
float f = HYPOT(X - mx, Y - my);
|
|
|
|
@ -427,31 +357,79 @@
|
|
|
|
return return_val;
|
|
|
|
return return_val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool unified_bed_leveling::look_for_lines_to_connect() {
|
|
|
|
/**
|
|
|
|
float sx, sy, ex, ey;
|
|
|
|
* 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
|
|
|
|
for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) {
|
|
|
|
* is the present location of the nozzle. We don't necessarily want to print from this location.
|
|
|
|
for (uint8_t j = 0; j < GRID_MAX_POINTS_Y; j++) {
|
|
|
|
* 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.
|
|
|
|
#if ENABLED(NEWPANEL)
|
|
|
|
*
|
|
|
|
if (user_canceled()) return true; // Check if the user wants to stop the Mesh Validation
|
|
|
|
* Note: Although we assume the first set of coordinates is the start of the line and the second
|
|
|
|
#endif
|
|
|
|
* 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
|
|
|
|
if (i < GRID_MAX_POINTS_X) { // We can't connect to anything to the right than GRID_MAX_POINTS_X.
|
|
|
|
* a lot of time and eliminates a lot of nonsensical movement of the nozzle. However, it does
|
|
|
|
// This is already a half circle because we are at the edge of the bed.
|
|
|
|
* 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
|
|
|
|
if (is_bit_set(circle_flags, i, j) && is_bit_set(circle_flags, i + 1, j)) { // check if we can do a line to the left
|
|
|
|
* cases where the optimization comes into play.
|
|
|
|
if (!is_bit_set(horizontal_mesh_line_flags, i, j)) {
|
|
|
|
*/
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) {
|
|
|
|
|
|
|
|
for (uint8_t j = 0; j < GRID_MAX_POINTS_Y; j++) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if ENABLED(NEWPANEL)
|
|
|
|
|
|
|
|
if (user_canceled()) return true; // Check if the user wants to stop the Mesh Validation
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (i < GRID_MAX_POINTS_X) { // We can't connect to anything to the right than GRID_MAX_POINTS_X.
|
|
|
|
|
|
|
|
// This is already a half circle because we are at the edge of the bed.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (is_bit_set(circle_flags, i, j) && is_bit_set(circle_flags, i + 1, j)) { // check if we can do a line to the left
|
|
|
|
|
|
|
|
if (!is_bit_set(horizontal_mesh_line_flags, i, j)) {
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// We found two circles that need a horizontal line to connect them
|
|
|
|
// We found two circles that need a horizontal line to connect them
|
|
|
|
// Print it!
|
|
|
|
// Print it!
|
|
|
|
//
|
|
|
|
//
|
|
|
|
sx = mesh_index_to_xpos( i ) + (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // right edge
|
|
|
|
sx = _GET_MESH_X( i ) + (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // right edge
|
|
|
|
ex = mesh_index_to_xpos(i + 1) - (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // left edge
|
|
|
|
ex = _GET_MESH_X(i + 1) - (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // left edge
|
|
|
|
|
|
|
|
|
|
|
|
sx = constrain(sx, X_MIN_POS + 1, X_MAX_POS - 1);
|
|
|
|
sx = constrain(sx, X_MIN_POS + 1, X_MAX_POS - 1);
|
|
|
|
sy = ey = constrain(mesh_index_to_ypos(j), Y_MIN_POS + 1, Y_MAX_POS - 1);
|
|
|
|
sy = ey = constrain(_GET_MESH_Y(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(sx, sy) && position_is_reachable(ex, ey)) {
|
|
|
|
if (position_is_reachable(sx, sy) && position_is_reachable(ex, ey)) {
|
|
|
|
@ -480,10 +458,10 @@
|
|
|
|
// We found two circles that need a vertical line to connect them
|
|
|
|
// We found two circles that need a vertical line to connect them
|
|
|
|
// Print it!
|
|
|
|
// Print it!
|
|
|
|
//
|
|
|
|
//
|
|
|
|
sy = mesh_index_to_ypos( j ) + (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // top edge
|
|
|
|
sy = _GET_MESH_Y( j ) + (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // top edge
|
|
|
|
ey = mesh_index_to_ypos(j + 1) - (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // bottom edge
|
|
|
|
ey = _GET_MESH_Y(j + 1) - (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // bottom edge
|
|
|
|
|
|
|
|
|
|
|
|
sx = ex = constrain(mesh_index_to_xpos(i), X_MIN_POS + 1, X_MAX_POS - 1);
|
|
|
|
sx = ex = constrain(_GET_MESH_X(i), X_MIN_POS + 1, X_MAX_POS - 1);
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
|
|
@ -496,7 +474,10 @@
|
|
|
|
SERIAL_ECHOPAIR(", ey=", ey);
|
|
|
|
SERIAL_ECHOPAIR(", ey=", ey);
|
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_EOL();
|
|
|
|
SERIAL_EOL();
|
|
|
|
debug_current_and_destination(PSTR("Connecting vertical line."));
|
|
|
|
|
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
|
|
|
|
debug_current_and_destination(PSTR("Connecting vertical line."));
|
|
|
|
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
print_line_from_here_to_there(sx, sy, g26_layer_height, ex, ey, g26_layer_height);
|
|
|
|
print_line_from_here_to_there(sx, sy, g26_layer_height, ex, ey, g26_layer_height);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -510,132 +491,106 @@
|
|
|
|
return false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void unified_bed_leveling::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);
|
|
|
|
/**
|
|
|
|
|
|
|
|
* 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) {
|
|
|
|
|
|
|
|
|
|
|
|
destination[X_AXIS] = x;
|
|
|
|
#if ENABLED(NEWPANEL)
|
|
|
|
destination[Y_AXIS] = y;
|
|
|
|
if (is_lcd_clicked()) return exit_from_g26();
|
|
|
|
destination[E_AXIS] += e_delta;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
G26_line_to_destination(feed_value);
|
|
|
|
if (ELAPSED(millis(), next)) {
|
|
|
|
|
|
|
|
next = millis() + 5000UL;
|
|
|
|
|
|
|
|
print_heaterstates();
|
|
|
|
|
|
|
|
SERIAL_EOL();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
idle();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ENABLED(ULTRA_LCD)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
lcd_setstatusPGM(PSTR("G26 Heating Nozzle."), 99);
|
|
|
|
|
|
|
|
lcd_quick_feedback();
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
stepper.synchronize();
|
|
|
|
// Start heating the nozzle and wait for it to reach temperature.
|
|
|
|
set_destination_from_current();
|
|
|
|
thermalManager.setTargetHotend(g26_hotend_temp, 0);
|
|
|
|
|
|
|
|
while (abs(thermalManager.degHotend(0) - g26_hotend_temp) > 3) {
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
#if ENABLED(NEWPANEL)
|
|
|
|
|
|
|
|
if (is_lcd_clicked()) return exit_from_g26();
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
void unified_bed_leveling::retract_filament(const float where[XYZE]) {
|
|
|
|
if (ELAPSED(millis(), next)) {
|
|
|
|
if (!g26_retracted) { // Only retract if we are not already retracted!
|
|
|
|
next = millis() + 5000UL;
|
|
|
|
g26_retracted = true;
|
|
|
|
print_heaterstates();
|
|
|
|
move_to(where, -1.0 * g26_retraction_multiplier);
|
|
|
|
SERIAL_EOL();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
idle();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void unified_bed_leveling::recover_filament(const float where[XYZE]) {
|
|
|
|
#if ENABLED(ULTRA_LCD)
|
|
|
|
if (g26_retracted) { // Only un-retract if we are retracted.
|
|
|
|
lcd_reset_status();
|
|
|
|
move_to(where, 1.2 * g26_retraction_multiplier);
|
|
|
|
lcd_quick_feedback();
|
|
|
|
g26_retracted = false;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return G26_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
/**
|
|
|
|
* print_line_from_here_to_there() takes two cartesian coordinates and draws a line from one
|
|
|
|
* G26: Mesh Validation Pattern generation.
|
|
|
|
* 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
|
|
|
|
* Used to interactively edit UBL's Mesh by placing the
|
|
|
|
* set of coordinates is the end of the line, it does not always work out that way. This function
|
|
|
|
* nozzle in a problem area and doing a G29 P4 R command.
|
|
|
|
* 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 unified_bed_leveling::print_line_from_here_to_there(const float &sx, const float &sy, const float &sz, const float &ex, const float &ey, const float &ez) {
|
|
|
|
void gcode_G26() {
|
|
|
|
const float dx_s = current_position[X_AXIS] - sx, // find our distance from the start of the actual line segment
|
|
|
|
SERIAL_ECHOLNPGM("G26 command started. Waiting for heater(s).");
|
|
|
|
dy_s = current_position[Y_AXIS] - sy,
|
|
|
|
float tmp, start_angle, end_angle;
|
|
|
|
dist_start = HYPOT2(dx_s, dy_s), // We don't need to do a sqrt(), we can compare the distance^2
|
|
|
|
int i, xi, yi;
|
|
|
|
// to save computation time
|
|
|
|
mesh_index_pair location;
|
|
|
|
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
|
|
|
|
// Don't allow Mesh Validation without homing first,
|
|
|
|
|
|
|
|
// or if the parameter parsing did not go OK, abort
|
|
|
|
|
|
|
|
if (axis_unhomed_error()) return;
|
|
|
|
|
|
|
|
|
|
|
|
const float e_pos_delta = line_length * g26_e_axis_feedrate * g26_extrusion_multiplier;
|
|
|
|
g26_extrusion_multiplier = EXTRUSION_MULTIPLIER;
|
|
|
|
|
|
|
|
g26_retraction_multiplier = RETRACTION_MULTIPLIER;
|
|
|
|
|
|
|
|
g26_layer_height = MESH_TEST_LAYER_HEIGHT;
|
|
|
|
|
|
|
|
g26_prime_length = PRIME_LENGTH;
|
|
|
|
|
|
|
|
g26_bed_temp = MESH_TEST_BED_TEMP;
|
|
|
|
|
|
|
|
g26_hotend_temp = MESH_TEST_HOTEND_TEMP;
|
|
|
|
|
|
|
|
g26_prime_flag = 0;
|
|
|
|
|
|
|
|
|
|
|
|
recover_filament(destination);
|
|
|
|
float g26_nozzle = MESH_TEST_NOZZLE_SIZE,
|
|
|
|
move_to(ex, ey, ez, e_pos_delta); // Get to the ending point with an appropriate amount of extrusion
|
|
|
|
g26_filament_diameter = DEFAULT_NOMINAL_FILAMENT_DIA,
|
|
|
|
}
|
|
|
|
g26_ooze_amount = parser.linearval('O', OOZE_AMOUNT);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
bool g26_continue_with_closest = parser.boolval('C'),
|
|
|
|
* This function used to be inline code in G26. But there are so many
|
|
|
|
g26_keep_heaters_on = parser.boolval('K');
|
|
|
|
* parameters it made sense to turn them into static globals and get
|
|
|
|
|
|
|
|
* this code out of sight of the main routine.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
bool unified_bed_leveling::parse_G26_parameters() {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
g26_extrusion_multiplier = EXTRUSION_MULTIPLIER;
|
|
|
|
|
|
|
|
g26_retraction_multiplier = RETRACTION_MULTIPLIER;
|
|
|
|
|
|
|
|
g26_nozzle = MESH_TEST_NOZZLE_SIZE;
|
|
|
|
|
|
|
|
g26_filament_diameter = DEFAULT_NOMINAL_FILAMENT_DIA;
|
|
|
|
|
|
|
|
g26_layer_height = MESH_TEST_LAYER_HEIGHT;
|
|
|
|
|
|
|
|
g26_prime_length = PRIME_LENGTH;
|
|
|
|
|
|
|
|
g26_bed_temp = MESH_TEST_BED_TEMP;
|
|
|
|
|
|
|
|
g26_hotend_temp = MESH_TEST_HOTEND_TEMP;
|
|
|
|
|
|
|
|
g26_prime_flag = 0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
g26_ooze_amount = parser.linearval('O', OOZE_AMOUNT);
|
|
|
|
|
|
|
|
g26_keep_heaters_on = parser.boolval('K');
|
|
|
|
|
|
|
|
g26_continue_with_closest = parser.boolval('C');
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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 UBL_ERR;
|
|
|
|
return G26_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -643,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 UBL_ERR;
|
|
|
|
return G26_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -652,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 UBL_ERR;
|
|
|
|
return G26_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
else {
|
|
|
|
SERIAL_PROTOCOLLNPGM("?Retraction Multiplier must be specified.");
|
|
|
|
SERIAL_PROTOCOLLNPGM("?Retraction Multiplier must be specified.");
|
|
|
|
return UBL_ERR;
|
|
|
|
return G26_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -665,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 UBL_ERR;
|
|
|
|
return G26_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -675,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 UBL_ERR;
|
|
|
|
return G26_ERR;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
else {
|
|
|
|
@ -683,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 UBL_ERR;
|
|
|
|
return G26_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -692,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 UBL_ERR;
|
|
|
|
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
|
|
|
|
@ -705,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 UBL_ERR;
|
|
|
|
return G26_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -715,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 UBL_ERR;
|
|
|
|
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 UBL_ERR;
|
|
|
|
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 UBL_ERR;
|
|
|
|
return G26_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
/**
|
|
|
|
@ -742,139 +698,175 @@
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
set_bed_leveling_enabled(!parser.seen('D'));
|
|
|
|
set_bed_leveling_enabled(!parser.seen('D'));
|
|
|
|
|
|
|
|
|
|
|
|
return UBL_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 unified_bed_leveling::exit_from_g26() {
|
|
|
|
|
|
|
|
lcd_setstatusPGM(PSTR("Leaving G26"), -1);
|
|
|
|
|
|
|
|
while (ubl_lcd_clicked()) idle();
|
|
|
|
|
|
|
|
return UBL_ERR;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
if (turn_on_heaters()) goto LEAVE;
|
|
|
|
* Turn on the bed and nozzle heat and
|
|
|
|
|
|
|
|
* wait for them to get up to temperature.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
bool unified_bed_leveling::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();
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
has_control_of_lcd_panel = true;
|
|
|
|
|
|
|
|
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 UBL_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 unified_bed_leveling::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);
|
|
|
|
|
|
|
|
|
|
|
|
has_control_of_lcd_panel = 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 UBL_ERR;
|
|
|
|
}
|
|
|
|
#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;
|
|
|
|
#endif
|
|
|
|
if (tmp_div_30 < 0) tmp_div_30 += 360 / 30;
|
|
|
|
|
|
|
|
if (tmp_div_30 > 11) tmp_div_30 -= 360 / 30;
|
|
|
|
|
|
|
|
|
|
|
|
has_control_of_lcd_panel = 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],
|
|
|
|
|
|
|
|
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 UBL_OK;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#endif // AUTO_BED_LEVELING_UBL && UBL_G26_MESH_VALIDATION
|
|
|
|
#endif // G26_MESH_VALIDATION
|
|
|
|
|
Scott Lahteine
7 years ago
committed by