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

Changes for parity with 1.1.x

Browse source
This commit is contained in:
Scott Lahteine 2017-12-06 16:56:30 -06:00
parent 6040d4080e
commit 2fde60da12
8 changed files with 105 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Marlin/src/feature/bedlevel/ubl/ubl.cpp
View file

@ -64,7 +64,7 @@
constexpr float unified_bed_leveling::_mesh_index_to_xpos[16], constexpr float unified_bed_leveling::_mesh_index_to_xpos[16],
unified_bed_leveling::_mesh_index_to_ypos[16]; unified_bed_leveling::_mesh_index_to_ypos[16];
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTIPANEL)
bool unified_bed_leveling::lcd_map_control = false; bool unified_bed_leveling::lcd_map_control = false;
#endif #endif

12
Marlin/src/feature/bedlevel/ubl/ubl.h
View file

@ -76,19 +76,23 @@ class unified_bed_leveling {
static int g29_grid_size; static int g29_grid_size;
#endif #endif
#if ENABLED(NEWPANEL)
static void move_z_with_encoder(const float &multiplier);
static float measure_point_with_encoder(); static float measure_point_with_encoder();
static float measure_business_card_thickness(float); static float measure_business_card_thickness(const float&);
static void manually_probe_remaining_mesh(const float&, const float&, const float&, const float&, const bool);
static void fine_tune_mesh(const float &rx, const float &ry, const bool do_ubl_mesh_map);
#endif
static bool g29_parameter_parsing(); static bool g29_parameter_parsing();
static void find_mean_mesh_height(); static void find_mean_mesh_height();
static void shift_mesh_height(); static void shift_mesh_height();
static void probe_entire_mesh(const float &rx, const float &ry, const bool do_ubl_mesh_map, const bool stow_probe, bool do_furthest); static void probe_entire_mesh(const float &rx, const float &ry, const bool do_ubl_mesh_map, const bool stow_probe, bool do_furthest);
static void manually_probe_remaining_mesh(const float&, const float&, const float&, const float&, const bool);
static void tilt_mesh_based_on_3pts(const float &z1, const float &z2, const float &z3); static void tilt_mesh_based_on_3pts(const float &z1, const float &z2, const float &z3);
static void tilt_mesh_based_on_probed_grid(const bool do_ubl_mesh_map); static void tilt_mesh_based_on_probed_grid(const bool do_ubl_mesh_map);
static void g29_what_command(); static void g29_what_command();
static void g29_eeprom_dump(); static void g29_eeprom_dump();
static void g29_compare_current_mesh_to_stored_mesh(); static void g29_compare_current_mesh_to_stored_mesh();
static void fine_tune_mesh(const float &rx, const float &ry, const bool do_ubl_mesh_map);
static bool smart_fill_one(const uint8_t x, const uint8_t y, const int8_t xdir, const int8_t ydir); static bool smart_fill_one(const uint8_t x, const uint8_t y, const int8_t xdir, const int8_t ydir);
static void smart_fill_mesh(); static void smart_fill_mesh();
@ -137,7 +141,7 @@ class unified_bed_leveling {
MESH_MIN_Y + 14 * (MESH_Y_DIST), MESH_MIN_Y + 15 * (MESH_Y_DIST) MESH_MIN_Y + 14 * (MESH_Y_DIST), MESH_MIN_Y + 15 * (MESH_Y_DIST)
}; };
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTIPANEL)
static bool lcd_map_control; static bool lcd_map_control;
#endif #endif

22
Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp
View file

@ -458,7 +458,7 @@
parser.seen('T'), parser.seen('E'), parser.seen('U')); parser.seen('T'), parser.seen('E'), parser.seen('U'));
break; break;
#endif #endif // HAS_BED_PROBE
case 2: { case 2: {
#if ENABLED(NEWPANEL) #if ENABLED(NEWPANEL)
@ -913,7 +913,7 @@
static void echo_and_take_a_measurement() { SERIAL_PROTOCOLLNPGM(" and take a measurement."); } static void echo_and_take_a_measurement() { SERIAL_PROTOCOLLNPGM(" and take a measurement."); }
float unified_bed_leveling::measure_business_card_thickness(const float in_height) { float unified_bed_leveling::measure_business_card_thickness(const float &in_height) {
lcd_external_control = true; lcd_external_control = true;
save_ubl_active_state_and_disable(); // Disable bed level correction for probing save_ubl_active_state_and_disable(); // Disable bed level correction for probing
@ -1033,7 +1033,6 @@
KEEPALIVE_STATE(IN_HANDLER); KEEPALIVE_STATE(IN_HANDLER);
do_blocking_move_to(rx, ry, Z_CLEARANCE_DEPLOY_PROBE); do_blocking_move_to(rx, ry, Z_CLEARANCE_DEPLOY_PROBE);
} }
#endif // NEWPANEL #endif // NEWPANEL
bool unified_bed_leveling::g29_parameter_parsing() { bool unified_bed_leveling::g29_parameter_parsing() {
@ -1341,11 +1340,10 @@
z_values[x][y] -= tmp_z_values[x][y]; z_values[x][y] -= tmp_z_values[x][y];
} }
mesh_index_pair unified_bed_leveling::find_furthest_invalid_mesh_point() { mesh_index_pair unified_bed_leveling::find_furthest_invalid_mesh_point() {
bool found_a_NAN = false; bool found_a_NAN = false, found_a_real = false;
bool found_a_real = false;
mesh_index_pair out_mesh; mesh_index_pair out_mesh;
out_mesh.x_index = out_mesh.y_index = -1; out_mesh.x_index = out_mesh.y_index = -1;
out_mesh.distance = -99999.99; out_mesh.distance = -99999.99;
@ -1452,6 +1450,7 @@
} }
} // for j } // for j
} // for i } // for i
return out_mesh; return out_mesh;
} }
@ -1499,15 +1498,8 @@
if (!position_is_reachable(rawx, rawy)) // SHOULD NOT OCCUR because find_closest_mesh_point_of_type will only return reachable if (!position_is_reachable(rawx, rawy)) // SHOULD NOT OCCUR because find_closest_mesh_point_of_type will only return reachable
break; break;
float new_z = z_values[location.x_index][location.y_index];
if (isnan(new_z)) // if the mesh point is invalid, set it to 0.0 so it can be edited
new_z = 0.0;
do_blocking_move_to(rawx, rawy, Z_CLEARANCE_BETWEEN_PROBES); // Move the nozzle to the edit point do_blocking_move_to(rawx, rawy, Z_CLEARANCE_BETWEEN_PROBES); // Move the nozzle to the edit point
new_z = FLOOR(new_z * 1000.0) * 0.001; // Chop off digits after the 1000ths place
KEEPALIVE_STATE(PAUSED_FOR_USER); KEEPALIVE_STATE(PAUSED_FOR_USER);
lcd_external_control = true; lcd_external_control = true;
@ -1515,6 +1507,10 @@
lcd_refresh(); lcd_refresh();
float new_z = z_values[location.x_index][location.y_index];
if (isnan(new_z)) new_z = 0.0; // Set invalid mesh points to 0.0 so they can be edited
new_z = FLOOR(new_z * 1000.0) * 0.001; // Chop off digits after the 1000ths place
lcd_mesh_edit_setup(new_z); lcd_mesh_edit_setup(new_z);
do { do {

17
Marlin/src/gcode/bedlevel/G26.cpp
View file

@ -53,6 +53,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
* *
@ -268,9 +271,7 @@ void move_to(const float &rx, const float &ry, const float &z, const float &e_de
set_destination_from_current(); set_destination_from_current();
} }
FORCE_INLINE void move_to(const float where[XYZE], const float &de) { FORCE_INLINE void move_to(const float where[XYZE], const float &de) { move_to(where[X_AXIS], where[Y_AXIS], where[Z_AXIS], de); }
move_to(where[X_AXIS], where[Y_AXIS], where[Z_AXIS], de);
}
void retract_filament(const float where[XYZE]) { void retract_filament(const float where[XYZE]) {
if (!g26_retracted) { // Only retract if we are not already retracted! if (!g26_retracted) { // Only retract if we are not already retracted!
@ -314,9 +315,8 @@ void print_line_from_here_to_there(const float &sx, const float &sy, const float
// If the end point of the line is closer to the nozzle, flip the direction, // 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. // 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)) { 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); return print_line_from_here_to_there(ex, ey, ez, sx, sy, sz);
}
// Decide whether to retract & bump // Decide whether to retract & bump
@ -373,7 +373,6 @@ inline bool look_for_lines_to_connect() {
SERIAL_EOL(); SERIAL_EOL();
//debug_current_and_destination(PSTR("Connecting horizontal line.")); //debug_current_and_destination(PSTR("Connecting horizontal line."));
} }
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);
} }
bitmap_set(horizontal_mesh_line_flags, i, j); // Mark it as done so we don't do it again, even if we skipped it bitmap_set(horizontal_mesh_line_flags, i, j); // Mark it as done so we don't do it again, even if we skipped it
@ -405,8 +404,8 @@ inline bool look_for_lines_to_connect() {
SERIAL_ECHOPAIR(", ey=", ey); SERIAL_ECHOPAIR(", ey=", ey);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL(); SERIAL_EOL();
#if ENABLED(AUTO_BED_LEVELING_UBL) #if ENABLED(AUTO_BED_LEVELING_UBL)
void debug_current_and_destination(const char *title);
debug_current_and_destination(PSTR("Connecting vertical line.")); debug_current_and_destination(PSTR("Connecting vertical line."));
#endif #endif
} }
@ -678,9 +677,8 @@ void GcodeSuite::G26() {
return; return;
} }
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; return;
@ -727,6 +725,7 @@ void GcodeSuite::G26() {
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTRA_LCD)
lcd_external_control = true; lcd_external_control = true;
#endif #endif
//debug_current_and_destination(PSTR("Starting G26 Mesh Validation Pattern.")); //debug_current_and_destination(PSTR("Starting G26 Mesh Validation Pattern."));
/** /**

4
Marlin/src/inc/SanityCheck.h
View file

@ -313,11 +313,15 @@ static_assert(X_MAX_LENGTH >= X_BED_SIZE && Y_MAX_LENGTH >= Y_BED_SIZE,
#if ENABLED(LCD_PROGRESS_BAR) #if ENABLED(LCD_PROGRESS_BAR)
#if DISABLED(SDSUPPORT) #if DISABLED(SDSUPPORT)
#error "LCD_PROGRESS_BAR requires SDSUPPORT." #error "LCD_PROGRESS_BAR requires SDSUPPORT."
#elif DISABLED(ULTRA_LCD)
#error "LCD_PROGRESS_BAR requires a character LCD."
#elif ENABLED(DOGLCD) #elif ENABLED(DOGLCD)
#error "LCD_PROGRESS_BAR does not apply to graphical displays." #error "LCD_PROGRESS_BAR does not apply to graphical displays."
#elif ENABLED(FILAMENT_LCD_DISPLAY) #elif ENABLED(FILAMENT_LCD_DISPLAY)
#error "LCD_PROGRESS_BAR and FILAMENT_LCD_DISPLAY are not fully compatible. Comment out this line to use both." #error "LCD_PROGRESS_BAR and FILAMENT_LCD_DISPLAY are not fully compatible. Comment out this line to use both."
#endif #endif
#elif ENABLED(LCD_SET_PROGRESS_MANUALLY) && DISABLED(DOGLCD)
#error "LCD_SET_PROGRESS_MANUALLY requires LCD_PROGRESS_BAR or Graphical LCD."
#endif #endif
/** /**

64
Marlin/src/lcd/ultralcd.cpp
View file

@ -85,12 +85,13 @@ int16_t lcd_preheat_hotend_temp[2], lcd_preheat_bed_temp[2], lcd_preheat_fan_spe
#endif #endif
uint8_t lcd_status_update_delay = 1, // First update one loop delayed uint8_t lcd_status_update_delay = 1, // First update one loop delayed
lcd_status_message_level; // Higher level overrides lower lcd_status_message_level; // Higher level blocks lower level
char lcd_status_message[3 * (LCD_WIDTH) + 1] = WELCOME_MSG; // worst case is kana with up to 3*LCD_WIDTH+1 char lcd_status_message[3 * (LCD_WIDTH) + 1] = WELCOME_MSG; // worst case is kana with up to 3*LCD_WIDTH+1
#if ENABLED(STATUS_MESSAGE_SCROLLING) #if ENABLED(STATUS_MESSAGE_SCROLLING)
uint8_t status_scroll_pos = 0; uint8_t status_scroll_pos = 0;
#endif #endif
#if ENABLED(SCROLL_LONG_FILENAMES) #if ENABLED(SCROLL_LONG_FILENAMES)
uint8_t filename_scroll_pos, filename_scroll_max, filename_scroll_hash; uint8_t filename_scroll_pos, filename_scroll_max, filename_scroll_hash;
#endif #endif
@ -163,8 +164,6 @@ uint16_t max_display_update_time = 0;
extern bool powersupply_on; extern bool powersupply_on;
#endif #endif
float move_menu_scale;
//////////////////////////////////////////// ////////////////////////////////////////////
///////////////// Menu Tree //////////////// ///////////////// Menu Tree ////////////////
//////////////////////////////////////////// ////////////////////////////////////////////
@ -244,7 +243,6 @@ uint16_t max_display_update_time = 0;
void menu_action_setting_edit_callback_ ## _name(const char * const pstr, _type * const ptr, const _type minValue, const _type maxValue, const screenFunc_t callback, const bool live=false); \ void menu_action_setting_edit_callback_ ## _name(const char * const pstr, _type * const ptr, const _type minValue, const _type maxValue, const screenFunc_t callback, const bool live=false); \
typedef void _name##_void typedef void _name##_void
DECLARE_MENU_EDIT_TYPE(uint32_t, long5);
DECLARE_MENU_EDIT_TYPE(int16_t, int3); DECLARE_MENU_EDIT_TYPE(int16_t, int3);
DECLARE_MENU_EDIT_TYPE(uint8_t, int8); DECLARE_MENU_EDIT_TYPE(uint8_t, int8);
DECLARE_MENU_EDIT_TYPE(float, float3); DECLARE_MENU_EDIT_TYPE(float, float3);
@ -254,6 +252,7 @@ uint16_t max_display_update_time = 0;
DECLARE_MENU_EDIT_TYPE(float, float51); DECLARE_MENU_EDIT_TYPE(float, float51);
DECLARE_MENU_EDIT_TYPE(float, float52); DECLARE_MENU_EDIT_TYPE(float, float52);
DECLARE_MENU_EDIT_TYPE(float, float62); DECLARE_MENU_EDIT_TYPE(float, float62);
DECLARE_MENU_EDIT_TYPE(uint32_t, long5);
void menu_action_setting_edit_bool(const char* pstr, bool* ptr); void menu_action_setting_edit_bool(const char* pstr, bool* ptr);
void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, screenFunc_t callbackFunc); void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, screenFunc_t callbackFunc);
@ -566,10 +565,9 @@ uint16_t max_display_update_time = 0;
static bool no_reentry = false; static bool no_reentry = false;
if (lcdDrawUpdate) lcd_implementation_drawmenu_static(LCD_HEIGHT >= 4 ? 1 : 0, sync_message); if (lcdDrawUpdate) lcd_implementation_drawmenu_static(LCD_HEIGHT >= 4 ? 1 : 0, sync_message);
if (no_reentry) return; if (no_reentry) return;
// Make this the current handler till all moves are done // Make this the current handler till all moves are done
no_reentry = true; no_reentry = true;
screenFunc_t old_screen = currentScreen; const screenFunc_t old_screen = currentScreen;
lcd_goto_screen(_lcd_synchronize); lcd_goto_screen(_lcd_synchronize);
stepper.synchronize(); stepper.synchronize();
no_reentry = false; no_reentry = false;
@ -997,7 +995,7 @@ void kill_screen(const char* lcd_msg) {
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
if (card.cardOK) { if (card.cardOK) {
if (card.isFileOpen()) { if (card.isFileOpen()) {
if (IS_SD_PRINTING) if (card.sdprinting)
MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause); MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause);
else else
MENU_ITEM(function, MSG_RESUME_PRINT, lcd_sdcard_resume); MENU_ITEM(function, MSG_RESUME_PRINT, lcd_sdcard_resume);
@ -1115,6 +1113,8 @@ void kill_screen(const char* lcd_msg) {
ENCODER_DIRECTION_NORMAL(); ENCODER_DIRECTION_NORMAL();
if (encoderPosition) { if (encoderPosition) {
const int16_t babystep_increment = (int32_t)encoderPosition * (BABYSTEP_MULTIPLICATOR); const int16_t babystep_increment = (int32_t)encoderPosition * (BABYSTEP_MULTIPLICATOR);
encoderPosition = 0;
const float new_zoffset = zprobe_zoffset + planner.steps_to_mm[Z_AXIS] * babystep_increment; const float new_zoffset = zprobe_zoffset + planner.steps_to_mm[Z_AXIS] * babystep_increment;
if (WITHIN(new_zoffset, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX)) { if (WITHIN(new_zoffset, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX)) {
@ -1124,7 +1124,6 @@ void kill_screen(const char* lcd_msg) {
zprobe_zoffset = new_zoffset; zprobe_zoffset = new_zoffset;
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT; lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
} }
encoderPosition = 0;
} }
if (lcdDrawUpdate) { if (lcdDrawUpdate) {
lcd_implementation_drawedit(PSTR(MSG_ZPROBE_ZOFFSET), ftostr43sign(zprobe_zoffset)); lcd_implementation_drawedit(PSTR(MSG_ZPROBE_ZOFFSET), ftostr43sign(zprobe_zoffset));
@ -1164,12 +1163,13 @@ void kill_screen(const char* lcd_msg) {
mesh_edit_value = float(rounded - (rounded % 5L)) / 1000.0; mesh_edit_value = float(rounded - (rounded % 5L)) / 1000.0;
} }
if (lcdDrawUpdate) if (lcdDrawUpdate) {
lcd_implementation_drawedit(msg, ftostr43sign(mesh_edit_value)); lcd_implementation_drawedit(msg, ftostr43sign(mesh_edit_value));
#if ENABLED(MESH_EDIT_GFX_OVERLAY) #if ENABLED(MESH_EDIT_GFX_OVERLAY)
_lcd_zoffset_overlay_gfx(mesh_edit_value); _lcd_zoffset_overlay_gfx(mesh_edit_value);
#endif #endif
} }
}
void _lcd_mesh_edit_NOP() { void _lcd_mesh_edit_NOP() {
defer_return_to_status = true; defer_return_to_status = true;
@ -1182,7 +1182,7 @@ void kill_screen(const char* lcd_msg) {
return mesh_edit_value; return mesh_edit_value;
} }
void lcd_mesh_edit_setup(float initial) { void lcd_mesh_edit_setup(const float initial) {
mesh_edit_value = mesh_edit_accumulator = initial; mesh_edit_value = mesh_edit_accumulator = initial;
lcd_goto_screen(_lcd_mesh_edit_NOP); lcd_goto_screen(_lcd_mesh_edit_NOP);
} }
@ -1203,6 +1203,7 @@ void kill_screen(const char* lcd_msg) {
#endif // AUTO_BED_LEVELING_UBL #endif // AUTO_BED_LEVELING_UBL
/** /**
* Watch temperature callbacks * Watch temperature callbacks
*/ */
@ -2030,8 +2031,8 @@ void kill_screen(const char* lcd_msg) {
*/ */
void _lcd_ubl_adjust_height_cmd() { void _lcd_ubl_adjust_height_cmd() {
char UBL_LCD_GCODE[16]; char UBL_LCD_GCODE[16];
const int ind = ubl_height_amount < 0 ? 6 : 7; const int ind = ubl_height_amount > 0 ? 9 : 10;
strcpy_P(UBL_LCD_GCODE, PSTR("G29 P6-")); strcpy_P(UBL_LCD_GCODE, PSTR("G29 P6 C -"));
sprintf_P(&UBL_LCD_GCODE[ind], PSTR(".%i"), abs(ubl_height_amount)); sprintf_P(&UBL_LCD_GCODE[ind], PSTR(".%i"), abs(ubl_height_amount));
enqueue_and_echo_command(UBL_LCD_GCODE); enqueue_and_echo_command(UBL_LCD_GCODE);
} }
@ -2047,8 +2048,7 @@ void kill_screen(const char* lcd_msg) {
void _lcd_ubl_height_adjust_menu() { void _lcd_ubl_height_adjust_menu() {
START_MENU(); START_MENU();
MENU_BACK(MSG_UBL_EDIT_MESH_MENU); MENU_BACK(MSG_UBL_EDIT_MESH_MENU);
MENU_ITEM_EDIT(int3, MSG_UBL_MESH_HEIGHT_AMOUNT, &ubl_height_amount, -9, 9); MENU_ITEM_EDIT_CALLBACK(int3, MSG_UBL_MESH_HEIGHT_AMOUNT, &ubl_height_amount, -9, 9, _lcd_ubl_adjust_height_cmd);
MENU_ITEM(function, MSG_UBL_MESH_HEIGHT_ADJUST, _lcd_ubl_adjust_height_cmd);
MENU_ITEM(function, MSG_WATCH, lcd_return_to_status); MENU_ITEM(function, MSG_WATCH, lcd_return_to_status);
END_MENU(); END_MENU();
} }
@ -2184,8 +2184,7 @@ void kill_screen(const char* lcd_msg) {
void _lcd_ubl_fillin_menu() { void _lcd_ubl_fillin_menu() {
START_MENU(); START_MENU();
MENU_BACK(MSG_UBL_BUILD_MESH_MENU); MENU_BACK(MSG_UBL_BUILD_MESH_MENU);
MENU_ITEM_EDIT(int3, MSG_UBL_FILLIN_AMOUNT, &ubl_fillin_amount, 0, 9); MENU_ITEM_EDIT_CALLBACK(int3, MSG_UBL_FILLIN_AMOUNT, &ubl_fillin_amount, 0, 9, _lcd_ubl_fillin_amount_cmd);
MENU_ITEM(function, MSG_UBL_FILLIN_MESH, _lcd_ubl_fillin_amount_cmd);
MENU_ITEM(function, MSG_UBL_SMART_FILLIN, _lcd_ubl_smart_fillin_cmd); MENU_ITEM(function, MSG_UBL_SMART_FILLIN, _lcd_ubl_smart_fillin_cmd);
MENU_ITEM(gcode, MSG_UBL_MANUAL_FILLIN, PSTR("G29 P2 B T0")); MENU_ITEM(gcode, MSG_UBL_MANUAL_FILLIN, PSTR("G29 P2 B T0"));
MENU_ITEM(function, MSG_WATCH, lcd_return_to_status); MENU_ITEM(function, MSG_WATCH, lcd_return_to_status);
@ -2644,6 +2643,8 @@ void kill_screen(const char* lcd_msg) {
END_MENU(); END_MENU();
} }
float move_menu_scale;
#if ENABLED(DELTA_CALIBRATION_MENU) || (ENABLED(DELTA_AUTO_CALIBRATION) && !HAS_BED_PROBE) #if ENABLED(DELTA_CALIBRATION_MENU) || (ENABLED(DELTA_AUTO_CALIBRATION) && !HAS_BED_PROBE)
void lcd_move_z(); void lcd_move_z();
@ -2653,13 +2654,11 @@ void kill_screen(const char* lcd_msg) {
reset_bed_level(); // After calibration bed-level data is no longer valid reset_bed_level(); // After calibration bed-level data is no longer valid
#endif #endif
float z_dest = (Z_CLEARANCE_BETWEEN_PROBES) + (DELTA_PRINTABLE_RADIUS) / 5; line_to_z((Z_CLEARANCE_BETWEEN_PROBES) + (DELTA_PRINTABLE_RADIUS) / 5);
line_to_z(z_dest);
current_position[X_AXIS] = rx; current_position[X_AXIS] = rx;
current_position[Y_AXIS] = ry; current_position[Y_AXIS] = ry;
line_to_current_z(); line_to_current_z();
z_dest = Z_CLEARANCE_BETWEEN_PROBES; line_to_z(Z_CLEARANCE_BETWEEN_PROBES);
line_to_z(z_dest);
lcd_synchronize(); lcd_synchronize();
move_menu_scale = PROBE_MANUALLY_STEP; move_menu_scale = PROBE_MANUALLY_STEP;
@ -2813,7 +2812,6 @@ void kill_screen(const char* lcd_msg) {
#endif #endif
manual_move_e_index = eindex >= 0 ? eindex : active_extruder; manual_move_e_index = eindex >= 0 ? eindex : active_extruder;
#endif #endif
manual_move_start_time = millis() + (move_menu_scale < 0.99 ? 0UL : 250UL); // delay for bigger moves manual_move_start_time = millis() + (move_menu_scale < 0.99 ? 0UL : 250UL); // delay for bigger moves
manual_move_axis = (int8_t)axis; manual_move_axis = (int8_t)axis;
} }
@ -2830,6 +2828,7 @@ void kill_screen(const char* lcd_msg) {
if (encoderPosition && !processing_manual_move) { if (encoderPosition && !processing_manual_move) {
gcode.refresh_cmd_timeout(); gcode.refresh_cmd_timeout();
// Start with no limits to movement
float min = current_position[axis] - 1000, float min = current_position[axis] - 1000,
max = current_position[axis] + 1000; max = current_position[axis] + 1000;
@ -2867,7 +2866,7 @@ void kill_screen(const char* lcd_msg) {
// This assumes the center is 0,0 // This assumes the center is 0,0
#if ENABLED(DELTA) #if ENABLED(DELTA)
if (axis != Z_AXIS) { if (axis != Z_AXIS) {
max = SQRT(sq((float)(DELTA_PRINTABLE_RADIUS)) - sq(current_position[Y_AXIS - axis])); max = SQRT(sq((float)(DELTA_PRINTABLE_RADIUS)) - sq(current_position[Y_AXIS - axis])); // (Y_AXIS - axis) == the other axis
min = -max; min = -max;
} }
#endif #endif
@ -3131,7 +3130,7 @@ void kill_screen(const char* lcd_msg) {
MENU_ITEM(submenu, MSG_FILAMENT, lcd_control_filament_menu); MENU_ITEM(submenu, MSG_FILAMENT, lcd_control_filament_menu);
#if HAS_LCD_CONTRAST #if HAS_LCD_CONTRAST
MENU_ITEM_EDIT_CALLBACK(int3, MSG_CONTRAST, (int16_t*)&lcd_contrast, LCD_CONTRAST_MIN, LCD_CONTRAST_MAX, lcd_callback_set_contrast, true); MENU_ITEM_EDIT_CALLBACK(int3, MSG_CONTRAST, &lcd_contrast, LCD_CONTRAST_MIN, LCD_CONTRAST_MAX, lcd_callback_set_contrast, true);
#endif #endif
#if ENABLED(FWRETRACT) #if ENABLED(FWRETRACT)
MENU_ITEM(submenu, MSG_RETRACT, lcd_control_retract_menu); MENU_ITEM(submenu, MSG_RETRACT, lcd_control_retract_menu);
@ -3724,7 +3723,7 @@ void kill_screen(const char* lcd_msg) {
lcd_goto_screen(lcd_sdcard_menu, last_sdfile_encoderPosition); lcd_goto_screen(lcd_sdcard_menu, last_sdfile_encoderPosition);
defer_return_to_status = true; defer_return_to_status = true;
last_sdfile_encoderPosition == 0xFFFF; last_sdfile_encoderPosition = 0xFFFF;
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
lcd_update(); lcd_update();
@ -3749,7 +3748,6 @@ void kill_screen(const char* lcd_msg) {
MENU_ITEM(function, LCD_STR_FOLDER "..", lcd_sd_updir); MENU_ITEM(function, LCD_STR_FOLDER "..", lcd_sd_updir);
} }
if (fileCnt) {
for (uint16_t i = 0; i < fileCnt; i++) { for (uint16_t i = 0; i < fileCnt; i++) {
if (_menuLineNr == _thisItemNr) { if (_menuLineNr == _thisItemNr) {
const uint16_t nr = const uint16_t nr =
@ -3773,7 +3771,6 @@ void kill_screen(const char* lcd_msg) {
MENU_ITEM_DUMMY(); MENU_ITEM_DUMMY();
} }
} }
}
END_MENU(); END_MENU();
} }
@ -4476,13 +4473,14 @@ void lcd_init() {
lcd_implementation_init(); lcd_implementation_init();
#if ENABLED(NEWPANEL) #if ENABLED(NEWPANEL)
#if BUTTON_EXISTS(EN1) #if BUTTON_EXISTS(EN1)
SET_INPUT_PULLUP(BTN_EN1); SET_INPUT_PULLUP(BTN_EN1);
#endif #endif
#if BUTTON_EXISTS(EN2) #if BUTTON_EXISTS(EN2)
SET_INPUT_PULLUP(BTN_EN2); SET_INPUT_PULLUP(BTN_EN2);
#endif #endif
#if BUTTON_EXISTS(ENC) #if BUTTON_EXISTS(ENC)
SET_INPUT_PULLUP(BTN_ENC); SET_INPUT_PULLUP(BTN_ENC);
#endif #endif
@ -4684,7 +4682,7 @@ void lcd_update() {
#endif #endif
bool encoderPastThreshold = (abs(encoderDiff) >= ENCODER_PULSES_PER_STEP); const bool encoderPastThreshold = (abs(encoderDiff) >= ENCODER_PULSES_PER_STEP);
if (encoderPastThreshold || lcd_clicked) { if (encoderPastThreshold || lcd_clicked) {
if (encoderPastThreshold) { if (encoderPastThreshold) {
int32_t encoderMultiplier = 1; int32_t encoderMultiplier = 1;
@ -4979,11 +4977,6 @@ void lcd_reset_alert_level() { lcd_status_message_level = 0; }
if (BUTTON_PRESSED(ENC)) newbutton |= EN_C; if (BUTTON_PRESSED(ENC)) newbutton |= EN_C;
#endif #endif
buttons = newbutton;
#if ENABLED(LCD_HAS_SLOW_BUTTONS)
buttons |= slow_buttons;
#endif
// //
// Directional buttons // Directional buttons
// //
@ -5032,6 +5025,11 @@ void lcd_reset_alert_level() { lcd_status_message_level = 0; }
#endif // LCD_HAS_DIRECTIONAL_BUTTONS #endif // LCD_HAS_DIRECTIONAL_BUTTONS
buttons = newbutton;
#if ENABLED(LCD_HAS_SLOW_BUTTONS)
buttons |= slow_buttons;
#endif
#if ENABLED(ADC_KEYPAD) #if ENABLED(ADC_KEYPAD)
uint8_t newbutton_reprapworld_keypad = 0; uint8_t newbutton_reprapworld_keypad = 0;

11
Marlin/src/module/planner.cpp
View file

@ -135,15 +135,20 @@ float Planner::min_feedrate_mm_s,
Planner::inverse_z_fade_height, Planner::inverse_z_fade_height,
Planner::last_fade_z; Planner::last_fade_z;
#endif #endif
#else
constexpr bool Planner::leveling_active;
#endif #endif
#if ENABLED(SKEW_CORRECTION) #if ENABLED(SKEW_CORRECTION)
#if ENABLED(SKEW_CORRECTION_GCODE) #if ENABLED(SKEW_CORRECTION_GCODE)
// Initialized by settings.load()
float Planner::xy_skew_factor; float Planner::xy_skew_factor;
#if ENABLED(SKEW_CORRECTION_FOR_Z) #else
float Planner::xz_skew_factor, Planner::yz_skew_factor; constexpr float Planner::xy_skew_factor;
#endif #endif
#if ENABLED(SKEW_CORRECTION_FOR_Z) && ENABLED(SKEW_CORRECTION_GCODE)
float Planner::xz_skew_factor, Planner::yz_skew_factor;
#else
constexpr float Planner::xz_skew_factor, Planner::yz_skew_factor;
#endif #endif
#endif #endif

11
Marlin/src/module/stepper.cpp
View file

@ -97,18 +97,13 @@ uint8_t Stepper::last_direction_bits = 0; // The next stepping-bits to be
int16_t Stepper::cleaning_buffer_counter = 0; int16_t Stepper::cleaning_buffer_counter = 0;
#if ENABLED(X_DUAL_ENDSTOPS) #if ENABLED(X_DUAL_ENDSTOPS)
bool Stepper::locked_x_motor = false; bool Stepper::locked_x_motor = false, Stepper::locked_x2_motor = false;
bool Stepper::locked_x2_motor = false;
#endif #endif
#if ENABLED(Y_DUAL_ENDSTOPS) #if ENABLED(Y_DUAL_ENDSTOPS)
bool Stepper::locked_y_motor = false; bool Stepper::locked_y_motor = false, Stepper::locked_y2_motor = false;
bool Stepper::locked_y2_motor = false;
#endif #endif
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
bool Stepper::locked_z_motor = false; bool Stepper::locked_z_motor = false, Stepper::locked_z2_motor = false;
bool Stepper::locked_z2_motor = false;
#endif #endif
long Stepper::counter_X = 0, long Stepper::counter_X = 0,