Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
…And save backlash, fil. sensor, ExtUI userdata to EEPROM.
- Loading branch information
1 parent
0181e57
commit 15357af
Showing
22 changed files
with
648 additions
and
296 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,139 @@ | ||
| /** | ||
| * Marlin 3D Printer Firmware | ||
| * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] | ||
| * | ||
| * Based on Sprinter and grbl. | ||
| * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm | ||
| * | ||
| * This program is free software: you can redistribute it and/or modify | ||
| * it under the terms of the GNU General Public License as published by | ||
| * the Free Software Foundation, either version 3 of the License, or | ||
| * (at your option) any later version. | ||
| * | ||
| * This program is distributed in the hope that it will be useful, | ||
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| * GNU General Public License for more details. | ||
| * | ||
| * You should have received a copy of the GNU General Public License | ||
| * along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
| * | ||
| */ | ||
|
|
||
| #include "../Marlin.h" | ||
|
|
||
| #if ENABLED(BACKLASH_COMPENSATION) | ||
|
|
||
| #include "backlash.h" | ||
| #include "../module/planner.h" | ||
|
|
||
| #if ENABLED(BACKLASH_GCODE) | ||
| uint8_t Backlash::correction = (BACKLASH_CORRECTION) * 0xFF; | ||
| #ifdef BACKLASH_DISTANCE_MM | ||
| float Backlash::distance_mm[XYZ] = BACKLASH_DISTANCE_MM; | ||
| #endif | ||
| #ifdef BACKLASH_SMOOTHING_MM | ||
| float Backlash::smoothing_mm = BACKLASH_SMOOTHING_MM; | ||
| #endif | ||
| #endif | ||
|
|
||
| #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING) | ||
| float Backlash::measured_mm[XYZ] = { 0 }; | ||
| uint8_t Backlash::measured_count[XYZ] = { 0 }; | ||
| #endif | ||
|
|
||
| Backlash backlash; | ||
|
|
||
| /** | ||
| * To minimize seams in the printed part, backlash correction only adds | ||
| * steps to the current segment (instead of creating a new segment, which | ||
| * causes discontinuities and print artifacts). | ||
| * | ||
| * With a non-zero BACKLASH_SMOOTHING_MM value the backlash correction is | ||
| * spread over multiple segments, smoothing out artifacts even more. | ||
| */ | ||
|
|
||
| void Backlash::add_correction_steps(const int32_t &da, const int32_t &db, const int32_t &dc, const uint8_t dm, block_t * const block) { | ||
| static uint8_t last_direction_bits; | ||
| uint8_t changed_dir = last_direction_bits ^ dm; | ||
| // Ignore direction change if no steps are taken in that direction | ||
| if (da == 0) CBI(changed_dir, X_AXIS); | ||
| if (db == 0) CBI(changed_dir, Y_AXIS); | ||
| if (dc == 0) CBI(changed_dir, Z_AXIS); | ||
| last_direction_bits ^= changed_dir; | ||
|
|
||
| if (correction == 0) return; | ||
|
|
||
| #ifdef BACKLASH_SMOOTHING_MM | ||
| // The segment proportion is a value greater than 0.0 indicating how much residual_error | ||
| // is corrected for in this segment. The contribution is based on segment length and the | ||
| // smoothing distance. Since the computation of this proportion involves a floating point | ||
| // division, defer computation until needed. | ||
| float segment_proportion = 0; | ||
|
|
||
| // Residual error carried forward across multiple segments, so correction can be applied | ||
| // to segments where there is no direction change. | ||
| static int32_t residual_error[XYZ] = { 0 }; | ||
| #else | ||
| // No leftover residual error from segment to segment | ||
| int32_t residual_error[XYZ] = { 0 }; | ||
| // No direction change, no correction. | ||
| if (!changed_dir) return; | ||
| #endif | ||
|
|
||
| const float f_corr = float(correction) / 255.0f; | ||
|
|
||
| LOOP_XYZ(axis) { | ||
| if (distance_mm[axis]) { | ||
| const bool reversing = TEST(dm,axis); | ||
|
|
||
| // When an axis changes direction, add axis backlash to the residual error | ||
| if (TEST(changed_dir, axis)) | ||
| residual_error[axis] += (reversing ? -f_corr : f_corr) * distance_mm[axis] * planner.settings.axis_steps_per_mm[axis]; | ||
|
|
||
| // Decide how much of the residual error to correct in this segment | ||
| int32_t error_correction = residual_error[axis]; | ||
| #ifdef BACKLASH_SMOOTHING_MM | ||
| if (error_correction && smoothing_mm != 0) { | ||
| // Take up a portion of the residual_error in this segment, but only when | ||
| // the current segment travels in the same direction as the correction | ||
| if (reversing == (error_correction < 0)) { | ||
| if (segment_proportion == 0) | ||
| segment_proportion = MIN(1.0f, block->millimeters / smoothing_mm); | ||
| error_correction = ceil(segment_proportion * error_correction); | ||
| } | ||
| else | ||
| error_correction = 0; // Don't take up any backlash in this segment, as it would subtract steps | ||
| } | ||
| #endif | ||
| // Making a correction reduces the residual error and modifies delta_mm | ||
| if (error_correction) { | ||
| block->steps[axis] += ABS(error_correction); | ||
| residual_error[axis] -= error_correction; | ||
| } | ||
| } | ||
| } | ||
| } | ||
|
|
||
| #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING) | ||
| #if USES_Z_MIN_PROBE_ENDSTOP | ||
| #define TEST_PROBE_PIN (READ(Z_MIN_PROBE_PIN) != Z_MIN_PROBE_ENDSTOP_INVERTING) | ||
| #else | ||
| #define TEST_PROBE_PIN (READ(Z_MIN_PIN) != Z_MIN_ENDSTOP_INVERTING) | ||
| #endif | ||
|
|
||
| // Measure Z backlash by raising nozzle in increments until probe deactivates | ||
| void Backlash::measure_with_probe() { | ||
| if (measured_count[Z_AXIS] == 255) return; | ||
|
|
||
| float start_height = current_position[Z_AXIS]; | ||
| while (current_position[Z_AXIS] < (start_height + BACKLASH_MEASUREMENT_LIMIT) && TEST_PROBE_PIN) | ||
| do_blocking_move_to_z(current_position[Z_AXIS] + BACKLASH_MEASUREMENT_RESOLUTION, MMM_TO_MMS(BACKLASH_MEASUREMENT_FEEDRATE)); | ||
|
|
||
| // The backlash from all probe points is averaged, so count the number of measurements | ||
| measured_mm[Z_AXIS] += current_position[Z_AXIS] - start_height; | ||
| measured_count[Z_AXIS]++; | ||
| } | ||
| #endif | ||
|
|
||
| #endif // BACKLASH_COMPENSATION |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,88 @@ | ||
| /** | ||
| * Marlin 3D Printer Firmware | ||
| * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] | ||
| * | ||
| * Based on Sprinter and grbl. | ||
| * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm | ||
| * | ||
| * This program is free software: you can redistribute it and/or modify | ||
| * it under the terms of the GNU General Public License as published by | ||
| * the Free Software Foundation, either version 3 of the License, or | ||
| * (at your option) any later version. | ||
| * | ||
| * This program is distributed in the hope that it will be useful, | ||
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| * GNU General Public License for more details. | ||
| * | ||
| * You should have received a copy of the GNU General Public License | ||
| * along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
| * | ||
| */ | ||
| #pragma once | ||
|
|
||
| #include "../inc/MarlinConfigPre.h" | ||
| #include "../module/planner.h" | ||
|
|
||
| class Backlash { | ||
| public: | ||
| #if ENABLED(BACKLASH_GCODE) | ||
| static uint8_t correction; | ||
| #ifdef BACKLASH_DISTANCE_MM | ||
| static float distance_mm[XYZ]; | ||
| #endif | ||
| #ifdef BACKLASH_SMOOTHING_MM | ||
| static float smoothing_mm; | ||
| #endif | ||
| static inline void set_correction(const float &v) { correction = MAX(0, MIN(1.0, v)) * all_on; } | ||
| static inline float get_correction() { return float(ui8_to_percent(correction)) / 100.0f; } | ||
| #elif ENABLED(BACKLASH_COMPENSATION) | ||
| static constexpr uint8_t correction = (BACKLASH_CORRECTION) * 0xFF; | ||
| #ifdef BACKLASH_DISTANCE_MM | ||
| static constexpr float distance_mm[XYZ] = BACKLASH_DISTANCE_MM; | ||
| #endif | ||
| #ifdef BACKLASH_SMOOTHING_MM | ||
| static constexpr float smoothing_mm = BACKLASH_SMOOTHING_MM; | ||
| #endif | ||
| static inline void set_correction(float) { } | ||
| static inline float get_correction() { return float(ui8_to_percent(correction)) / 100.0f; } | ||
| #else | ||
| static constexpr uint8_t correction = 0; | ||
| static inline void set_correction(float) { } | ||
| static inline float get_correction() { return 0; } | ||
| #endif | ||
|
|
||
| #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING) | ||
| private: | ||
| static float measured_mm[XYZ]; | ||
| static uint8_t measured_count[XYZ]; | ||
| public: | ||
| static void measure_with_probe(); | ||
| #endif | ||
|
|
||
| static inline float get_measurement(const uint8_t e) { | ||
| // Return the measurement averaged over all readings | ||
| return ( | ||
| #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING) | ||
| measured_count[e] > 0 ? measured_mm[e] / measured_count[e] : | ||
| #endif | ||
| 0 | ||
| ); | ||
| } | ||
|
|
||
| static inline bool has_measurement(const uint8_t e) { | ||
| return (false | ||
| #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING) | ||
| || (measured_count[e] > 0) | ||
| #endif | ||
| ); | ||
| } | ||
|
|
||
| static inline bool has_any_measurement() { | ||
| return has_measurement(X_AXIS) || has_measurement(Y_AXIS) || has_measurement(Z_AXIS); | ||
| } | ||
|
|
||
| void add_correction_steps(const int32_t &da, const int32_t &db, const int32_t &dc, const uint8_t dm, block_t * const block); | ||
| }; | ||
|
|
||
| extern Backlash backlash; |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.