From b8e4a6970bb7bee4afbed74d43f2ac30c89fce1d Mon Sep 17 00:00:00 2001 From: Roxy-3D Date: Thu, 23 Mar 2017 15:56:38 -0500 Subject: [PATCH] Get UBL up and running again All the changes to get the code into compliance with Marlin coding standards made UBL sick. This pretty much gets UBL back up and running. --- Marlin/Marlin_main.cpp | 27 ++++++++++++--- Marlin/UBL_G29.cpp | 78 ++++++++++++++++++------------------------ Marlin/stepper.cpp | 2 +- 3 files changed, 57 insertions(+), 50 deletions(-) diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 3a942bdb9..049d50198 100755 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -2266,7 +2266,7 @@ static void clean_up_after_endstop_or_probe_move() { #endif // HAS_BED_PROBE -#if PLANNER_LEVELING +#if PLANNER_LEVELING || ENABLED(AUTO_BED_LEVELING_UBL) /** * Turn bed leveling on or off, fixing the current * position as-needed. @@ -2309,10 +2309,7 @@ static void clean_up_after_endstop_or_probe_move() { planner.unapply_leveling(current_position); } #elif ENABLED(AUTO_BED_LEVELING_UBL) - if (ubl.state.eeprom_storage_slot == 0) { ubl.state.active = enable; - ubl.store_state(); - } #endif } @@ -2363,6 +2360,8 @@ static void clean_up_after_endstop_or_probe_move() { for (uint8_t x = 0; x < ABL_GRID_MAX_POINTS_X; x++) for (uint8_t y = 0; y < ABL_GRID_MAX_POINTS_Y; y++) bed_level_grid[x][y] = UNPROBED; + #elif ENABLED(AUTO_BED_LEVELING_UBL) + ubl.reset(); #endif #endif } @@ -3482,6 +3481,11 @@ inline void gcode_G4() { * */ inline void gcode_G28() { + #if ENABLED(AUTO_BED_LEVELING_UBL) + bool bed_leveling_state_at_entry=0; + bed_leveling_state_at_entry = ubl.state.active; + set_bed_leveling_enabled(false); + #endif #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(LEVELING)) { @@ -3638,6 +3642,10 @@ inline void gcode_G28() { #endif // Enable mesh leveling again + #if ENABLED(AUTO_BED_LEVELING_UBL) + set_bed_leveling_enabled(bed_leveling_state_at_entry); + #endif + #if ENABLED(MESH_BED_LEVELING) if (mbl.reactivate()) { set_bed_leveling_enabled(true); @@ -5060,6 +5068,10 @@ inline void gcode_M42() { * regenerated. */ inline void gcode_M48() { + #if ENABLED(AUTO_BED_LEVELING_UBL) + bool bed_leveling_state_at_entry=0; + bed_leveling_state_at_entry = ubl.state.active; + #endif if (axis_unhomed_error(true, true, true)) return; @@ -5283,6 +5295,11 @@ inline void gcode_M42() { set_bed_leveling_enabled(abl_was_enabled); #endif + #if ENABLED(AUTO_BED_LEVELING_UBL) + set_bed_leveling_enabled(bed_leveling_state_at_entry); + ubl.state.active = bed_leveling_state_at_entry; + #endif + report_current_position(); } @@ -8511,7 +8528,7 @@ void process_next_command() { gcode_G28(); break; - #if PLANNER_LEVELING + #if PLANNER_LEVELING || HAS_ABL case 29: // G29 Detailed Z probe, probes the bed at 3 or more points, // or provides access to the UBL System if enabled. gcode_G29(); diff --git a/Marlin/UBL_G29.cpp b/Marlin/UBL_G29.cpp index 6bf0ec4f4..74479bd5c 100644 --- a/Marlin/UBL_G29.cpp +++ b/Marlin/UBL_G29.cpp @@ -96,8 +96,7 @@ * specified height, no correction is applied and natural printer kenimatics take over. If no * number is specified for the command, 10mm is assumed to be reasonable. * - * G # Grid * Perform a Grid Based Leveling of the current Mesh using a grid with n points on - * a side. + * G # Grid * Perform a Grid Based Leveling of the current Mesh using a grid with n points on a side. * * H # Height Specify the Height to raise the nozzle after each manual probe of the bed. The * default is 5mm. @@ -267,12 +266,6 @@ * of the mesh, you are limited to 3-Point and Grid Leveling. (G29 P0 T and G29 P0 G * respectively.) * - * Z-Probe Sleds are not currently fully supported. There were too many complications caused - * by them to support them in the Unified Bed Leveling code. Support for them will be handled - * better in the upcoming Z-Probe Object that will happen during the Code Clean Up phase. (That - * is what they really are: A special case of the Z-Probe.) When a Z-Probe Object appears, it - * should slip in under the Unified Bed Leveling code without major trauma. - * * When you do a G28 and then a G29 P1 to automatically build your first mesh, you are going to notice * the Unified Bed Leveling probes points further and further away from the starting location. (The * starting location defaults to the center of the bed.) The original Grid and Mesh leveling used @@ -1076,11 +1069,6 @@ ubl.state.active = ubl_state_at_invocation; } - void g29_print_line(bool longer=false) { - SERIAL_PROTOCOLPGM(" -------------------------------------"); - if (longer) SERIAL_PROTOCOLPGM("-------------------"); - SERIAL_PROTOCOLLNPGM(" <----<<<"); - } /** * Much of the 'What?' command can be eliminated. But until we are fully debugged, it is @@ -1090,70 +1078,85 @@ int k = E2END - ubl_eeprom_start; statistics_flag++; - SERIAL_PROTOCOLLNPGM("Version #4: 10/30/2016 branch"); - SERIAL_PROTOCOLPGM("Unified Bed Leveling System "); + SERIAL_PROTOCOLPGM("Unified Bed Leveling System Version 1.00 "); if (ubl.state.active) - SERIAL_PROTOCOLPGM("Active."); + SERIAL_PROTOCOLPGM("Active.\n"); else - SERIAL_PROTOCOLPGM("Inactive."); - g29_print_line(); // These are just to help me find this info buried in the clutter + SERIAL_PROTOCOLPGM("Inactive.\n"); + SERIAL_EOL; + delay(50); if (ubl.state.eeprom_storage_slot == 0xFFFF) { SERIAL_PROTOCOLPGM("No Mesh Loaded."); - g29_print_line(); // These are just to help me find this info buried in the clutter } else { SERIAL_PROTOCOLPGM("Mesh: "); prt_hex_word(ubl.state.eeprom_storage_slot); SERIAL_PROTOCOLPGM(" Loaded. "); - g29_print_line(true); // These are just to help me find this info buried in the clutter } - SERIAL_PROTOCOLPAIR("\ng29_correction_fade_height : ", ubl.state.g29_correction_fade_height ); - g29_print_line(); // These are just to help me find this info buried in the clutter + SERIAL_EOL; + delay(50); + + SERIAL_PROTOCOLPAIR("g29_correction_fade_height : ", ubl.state.g29_correction_fade_height ); + SERIAL_EOL; idle(); SERIAL_PROTOCOLPGM("z_offset: "); SERIAL_PROTOCOL_F(ubl.state.z_offset, 6); - g29_print_line(true); // These are just to help me find this info buried in the clutter + SERIAL_EOL; SERIAL_PROTOCOLPGM("X-Axis Mesh Points at: "); for (uint8_t i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { SERIAL_PROTOCOL_F( ubl.map_x_index_to_bed_location(i), 1); SERIAL_PROTOCOLPGM(" "); + delay(10); } SERIAL_EOL; + delay(50); + idle(); + SERIAL_PROTOCOLPGM("Y-Axis Mesh Points at: "); for (uint8_t i = 0; i < UBL_MESH_NUM_Y_POINTS; i++) { SERIAL_PROTOCOL_F( ubl.map_y_index_to_bed_location(i), 1); SERIAL_PROTOCOLPGM(" "); + delay(10); } SERIAL_EOL; + delay(50); + idle(); #if HAS_KILL SERIAL_PROTOCOLPAIR("Kill pin on :", KILL_PIN); SERIAL_PROTOCOLLNPAIR(" state:", READ(KILL_PIN)); #endif + delay(50); + idle(); + SERIAL_EOL; SERIAL_PROTOCOLLNPAIR("ubl_state_at_invocation :", ubl_state_at_invocation); + SERIAL_EOL; SERIAL_PROTOCOLLNPAIR("ubl_state_recursion_chk :", ubl_state_recursion_chk); - SERIAL_EOL; SERIAL_PROTOCOLPGM("Free EEPROM space starts at: 0x"); prt_hex_word(ubl_eeprom_start); SERIAL_EOL; + delay(50); idle(); SERIAL_PROTOCOLPGM("end of EEPROM : "); prt_hex_word(E2END); SERIAL_EOL; + delay(50); idle(); SERIAL_PROTOCOLLNPAIR("sizeof(ubl) : ", (int)sizeof(ubl)); SERIAL_EOL; SERIAL_PROTOCOLLNPAIR("z_value[][] size: ", (int)sizeof(z_values)); SERIAL_EOL; + delay(50); + idle(); SERIAL_PROTOCOLPGM("EEPROM free for UBL: 0x"); prt_hex_word(k); @@ -1162,41 +1165,28 @@ SERIAL_PROTOCOLPGM("EEPROM can hold 0x"); prt_hex_word(k / sizeof(z_values)); - SERIAL_PROTOCOLLNPGM(" meshes."); + SERIAL_PROTOCOLLNPGM(" meshes.\n"); + delay(50); - SERIAL_PROTOCOLPGM("sizeof(stat) :"); + SERIAL_PROTOCOLPGM("sizeof(ubl.state) :"); prt_hex_word(sizeof(ubl.state)); - SERIAL_EOL; idle(); SERIAL_PROTOCOLPAIR("\nUBL_MESH_NUM_X_POINTS ", UBL_MESH_NUM_X_POINTS); SERIAL_PROTOCOLPAIR("\nUBL_MESH_NUM_Y_POINTS ", UBL_MESH_NUM_Y_POINTS); SERIAL_PROTOCOLPAIR("\nUBL_MESH_MIN_X ", UBL_MESH_MIN_X); + delay(50); + idle(); SERIAL_PROTOCOLPAIR("\nUBL_MESH_MIN_Y ", UBL_MESH_MIN_Y); SERIAL_PROTOCOLPAIR("\nUBL_MESH_MAX_X ", UBL_MESH_MAX_X); SERIAL_PROTOCOLPAIR("\nUBL_MESH_MAX_Y ", UBL_MESH_MAX_Y); + delay(50); + idle(); SERIAL_PROTOCOLPGM("\nMESH_X_DIST "); SERIAL_PROTOCOL_F(MESH_X_DIST, 6); SERIAL_PROTOCOLPGM("\nMESH_Y_DIST "); SERIAL_PROTOCOL_F(MESH_Y_DIST, 6); SERIAL_EOL; - idle(); - - SERIAL_PROTOCOLPAIR("\nsizeof(block_t): ", (int)sizeof(block_t)); - SERIAL_PROTOCOLPAIR("\nsizeof(planner.block_buffer): ", (int)sizeof(planner.block_buffer)); - SERIAL_PROTOCOLPAIR("\nsizeof(char): ", (int)sizeof(char)); - SERIAL_PROTOCOLPAIR(" sizeof(unsigned char): ", (int)sizeof(unsigned char)); - SERIAL_PROTOCOLPAIR("\nsizeof(int): ", (int)sizeof(int)); - SERIAL_PROTOCOLPAIR(" sizeof(unsigned int): ", (int)sizeof(unsigned int)); - SERIAL_PROTOCOLPAIR("\nsizeof(long): ", (int)sizeof(long)); - SERIAL_PROTOCOLPAIR(" sizeof(unsigned long int): ", (int)sizeof(unsigned long int)); - SERIAL_PROTOCOLPAIR("\nsizeof(float): ", (int)sizeof(float)); - SERIAL_PROTOCOLPAIR(" sizeof(double): ", (int)sizeof(double)); - SERIAL_PROTOCOLPAIR("\nsizeof(void *): ", (int)sizeof(void *)); - struct pf { void *p_f(); } ptr_func; - SERIAL_PROTOCOLPAIR(" sizeof(struct pf): ", (int)sizeof(pf)); - SERIAL_PROTOCOLPAIR(" sizeof(void *()): ", (int)sizeof(ptr_func)); - SERIAL_EOL; idle(); diff --git a/Marlin/stepper.cpp b/Marlin/stepper.cpp index 9c69f3811..c91627e24 100644 --- a/Marlin/stepper.cpp +++ b/Marlin/stepper.cpp @@ -1263,7 +1263,7 @@ void Stepper::report_positions() { old_pin = _READ_DIR(X); #if STEP_PULSE_CYCLES > CYCLES_EATEN_BY_BABYSTEP pulse_start = TCNT0; - #endif \ + #endif START_BABYSTEP_AXIS(X, false); #if STEP_PULSE_CYCLES > CYCLES_EATEN_BY_BABYSTEP while ((uint32_t)(TCNT0 - pulse_start) < STEP_PULSE_CYCLES - CYCLES_EATEN_BY_BABYSTEP) { /* nada */ }