tompe-proj
5 years ago
committed by
Scott Lahteine
Scott Lahteine
16 changed files with 1017 additions and 42 deletions
@ -0,0 +1,223 @@ |
|||
/**
|
|||
* 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 "../inc/MarlinConfigPre.h" |
|||
|
|||
#if ENABLED(PROBE_TEMP_COMPENSATION) |
|||
|
|||
#include "probe_temp_compensation.h" |
|||
#include <math.h> |
|||
|
|||
ProbeTempComp temp_comp; |
|||
|
|||
int16_t ProbeTempComp::z_offsets_probe[ProbeTempComp::cali_info_init[TSI_PROBE].measurements], // = {0}
|
|||
ProbeTempComp::z_offsets_bed[ProbeTempComp::cali_info_init[TSI_BED].measurements]; // = {0}
|
|||
|
|||
#if ENABLED(USE_TEMP_EXT_COMPENSATION) |
|||
int16_t ProbeTempComp::z_offsets_ext[ProbeTempComp::cali_info_init[TSI_EXT].measurements]; // = {0}
|
|||
#endif |
|||
|
|||
int16_t *ProbeTempComp::sensor_z_offsets[TSI_COUNT] = { |
|||
ProbeTempComp::z_offsets_probe, ProbeTempComp::z_offsets_bed |
|||
#if ENABLED(USE_TEMP_EXT_COMPENSATION) |
|||
, ProbeTempComp::z_offsets_ext |
|||
#endif |
|||
}; |
|||
|
|||
const temp_calib_t ProbeTempComp::cali_info[TSI_COUNT] = { |
|||
ProbeTempComp::cali_info_init[TSI_PROBE], ProbeTempComp::cali_info_init[TSI_BED] |
|||
#if ENABLED(USE_TEMP_EXT_COMPENSATION) |
|||
, ProbeTempComp::cali_info_init[TSI_EXT] |
|||
#endif |
|||
}; |
|||
|
|||
uint8_t ProbeTempComp::calib_idx; // = 0
|
|||
float ProbeTempComp::init_measurement; // = 0.0
|
|||
|
|||
void ProbeTempComp::clear_offsets(const TempSensorID tsi) { |
|||
for (uint8_t i = 0; i < cali_info[tsi].measurements; ++i) |
|||
sensor_z_offsets[tsi][i] = 0; |
|||
calib_idx = 0; |
|||
} |
|||
|
|||
bool ProbeTempComp::set_offset(const TempSensorID tsi, const uint8_t idx, const int16_t offset) { |
|||
if (idx >= cali_info[tsi].measurements) return false; |
|||
sensor_z_offsets[tsi][idx] = offset; |
|||
return true; |
|||
} |
|||
|
|||
void ProbeTempComp::print_offsets() { |
|||
for (uint8_t s = 0; s < TSI_COUNT; s++) { |
|||
float temp = cali_info[s].start_temp; |
|||
for (int16_t i = -1; i < cali_info[s].measurements; ++i) { |
|||
serialprintPGM(s == TSI_BED ? PSTR("Bed") : |
|||
#if ENABLED(USE_TEMP_EXT_COMPENSATION) |
|||
s == TSI_EXT ? PSTR("Extruder") : |
|||
#endif |
|||
PSTR("Probe") |
|||
); |
|||
SERIAL_ECHOLNPAIR( |
|||
" temp: ", temp, |
|||
"C; Offset: ", i < 0 ? 0.0f : sensor_z_offsets[s][i], " um" |
|||
); |
|||
temp += cali_info[s].temp_res; |
|||
} |
|||
} |
|||
} |
|||
|
|||
void ProbeTempComp::prepare_new_calibration(const float &init_meas_z) { |
|||
calib_idx = 0; |
|||
init_measurement = init_meas_z; |
|||
} |
|||
|
|||
void ProbeTempComp::push_back_new_measurement(const TempSensorID tsi, const float &meas_z) { |
|||
switch (tsi) { |
|||
case TSI_PROBE: |
|||
case TSI_BED: |
|||
//case TSI_EXT:
|
|||
if (calib_idx >= cali_info[tsi].measurements) return; |
|||
sensor_z_offsets[tsi][calib_idx++] = static_cast<int16_t>(meas_z * 1000.0f - init_measurement * 1000.0f); |
|||
default: break; |
|||
} |
|||
} |
|||
|
|||
bool ProbeTempComp::finish_calibration(const TempSensorID tsi) { |
|||
if (tsi != TSI_PROBE && tsi != TSI_BED) return false; |
|||
|
|||
if (calib_idx < 3) { |
|||
SERIAL_ECHOLNPGM("!Insufficient measurements (min. 3)."); |
|||
clear_offsets(tsi); |
|||
return false; |
|||
} |
|||
|
|||
const uint8_t measurements = cali_info[tsi].measurements; |
|||
const float start_temp = cali_info[tsi].start_temp, |
|||
res_temp = cali_info[tsi].temp_res; |
|||
int16_t * const data = sensor_z_offsets[tsi]; |
|||
|
|||
// Extrapolate
|
|||
float k, d; |
|||
if (calib_idx < measurements) { |
|||
SERIAL_ECHOLNPAIR("Got ", calib_idx, " measurements. "); |
|||
if (linear_regression(tsi, k, d)) { |
|||
SERIAL_ECHOPGM("Applying linear extrapolation"); |
|||
calib_idx--; |
|||
for (; calib_idx < measurements; ++calib_idx) { |
|||
const float temp = start_temp + float(calib_idx) * res_temp; |
|||
data[calib_idx] = static_cast<int16_t>(k * temp + d); |
|||
} |
|||
} |
|||
else { |
|||
// Simply use the last measured value for higher temperatures
|
|||
SERIAL_ECHOPGM("Failed to extrapolate"); |
|||
const int16_t last_val = data[calib_idx]; |
|||
for (; calib_idx < measurements; ++calib_idx) |
|||
data[calib_idx] = last_val; |
|||
} |
|||
SERIAL_ECHOLNPGM(" for higher temperatures."); |
|||
} |
|||
|
|||
// Sanity check
|
|||
for (calib_idx = 0; calib_idx < measurements; ++calib_idx) { |
|||
// Restrict the max. offset
|
|||
if (abs(data[calib_idx]) > 2000) { |
|||
SERIAL_ECHOLNPGM("!Invalid Z-offset detected (0-2)."); |
|||
clear_offsets(tsi); |
|||
return false; |
|||
} |
|||
// Restrict the max. offset difference between two probings
|
|||
if (calib_idx > 0 && abs(data[calib_idx - 1] - data[calib_idx]) > 800) { |
|||
SERIAL_ECHOLNPGM("!Invalid Z-offset between two probings detected (0-0.8)."); |
|||
clear_offsets(TSI_PROBE); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
void ProbeTempComp::compensate_measurement(const TempSensorID tsi, const float &temp, float &meas_z) { |
|||
if (WITHIN(temp, cali_info[tsi].start_temp, cali_info[tsi].end_temp)) |
|||
meas_z -= get_offset_for_temperature(tsi, temp); |
|||
} |
|||
|
|||
float ProbeTempComp::get_offset_for_temperature(const TempSensorID tsi, const float &temp) { |
|||
|
|||
const uint8_t measurements = cali_info[tsi].measurements; |
|||
const float start_temp = cali_info[tsi].start_temp, |
|||
end_temp = cali_info[tsi].end_temp, |
|||
res_temp = cali_info[tsi].temp_res; |
|||
const int16_t * const data = sensor_z_offsets[tsi]; |
|||
|
|||
if (temp <= start_temp) return 0.0f; |
|||
if (temp >= end_temp) return static_cast<float>(data[measurements - 1]) / 1000.0f; |
|||
|
|||
// Linear interpolation
|
|||
int16_t val1 = 0, val2 = data[0]; |
|||
uint8_t idx = 0; |
|||
float meas_temp = start_temp + res_temp; |
|||
while (meas_temp < temp) { |
|||
if (++idx >= measurements) return static_cast<float>(val2) / 1000.0f; |
|||
meas_temp += res_temp; |
|||
val1 = val2; |
|||
val2 = data[idx]; |
|||
} |
|||
const float factor = (meas_temp - temp) / static_cast<float>(res_temp); |
|||
return (static_cast<float>(val2) - static_cast<float>(val2 - val1) * factor) / 1000.0f; |
|||
} |
|||
|
|||
bool ProbeTempComp::linear_regression(const TempSensorID tsi, float &k, float &d) { |
|||
if (tsi != TSI_PROBE && tsi != TSI_BED) return false; |
|||
|
|||
if (!WITHIN(calib_idx, 2, cali_info[tsi].measurements)) return false; |
|||
|
|||
const float start_temp = cali_info[tsi].start_temp, |
|||
res_temp = cali_info[tsi].temp_res; |
|||
const int16_t * const data = sensor_z_offsets[tsi]; |
|||
|
|||
float sum_x = start_temp, |
|||
sum_x2 = sq(start_temp), |
|||
sum_xy = 0, sum_y = 0; |
|||
|
|||
for (uint8_t i = 0; i < calib_idx; ++i) { |
|||
const float xi = start_temp + (i + 1) * res_temp, |
|||
yi = static_cast<float>(data[i]); |
|||
sum_x += xi; |
|||
sum_x2 += sq(xi); |
|||
sum_xy += xi * yi; |
|||
sum_y += yi; |
|||
} |
|||
|
|||
const float denom = static_cast<float>(calib_idx + 1) * sum_x2 - sq(sum_x); |
|||
if (fabs(denom) <= 10e-5) { |
|||
// Singularity - unable to solve
|
|||
k = d = 0.0; |
|||
return false; |
|||
} |
|||
|
|||
k = (static_cast<float>(calib_idx + 1) * sum_xy - sum_x * sum_y) / denom; |
|||
d = (sum_y - k * sum_x) / static_cast<float>(calib_idx + 1); |
|||
|
|||
return true; |
|||
} |
|||
|
|||
#endif // PROBE_TEMP_COMPENSATION
|
|||
@ -0,0 +1,116 @@ |
|||
/**
|
|||
* 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/MarlinConfig.h" |
|||
|
|||
enum TempSensorID : uint8_t { |
|||
TSI_PROBE, |
|||
TSI_BED, |
|||
#if ENABLED(USE_TEMP_EXT_COMPENSATION) |
|||
TSI_EXT, |
|||
#endif |
|||
TSI_COUNT |
|||
}; |
|||
|
|||
typedef struct { |
|||
uint8_t measurements; // Max. number of measurements to be stored (35 - 80°C)
|
|||
float temp_res, // Resolution in °C between measurements
|
|||
start_temp, // Base measurement; z-offset == 0
|
|||
end_temp; |
|||
} temp_calib_t; |
|||
|
|||
/**
|
|||
* Probe temperature compensation implementation. |
|||
* Z-probes like the P.I.N.D.A V2 allow for compensation of |
|||
* measurement errors/shifts due to changed temperature. |
|||
*/ |
|||
class ProbeTempComp { |
|||
public: |
|||
|
|||
static constexpr temp_calib_t cali_info_init[TSI_COUNT] = { |
|||
{ 30, 10, 5, 30 + 10 * 5 }, // Probe
|
|||
{ 60, 10, 5, 60 + 10 * 5 }, // Bed
|
|||
#if ENABLED(USE_TEMP_EXT_COMPENSATION) |
|||
{ 180, 5, 20, 180 + 5 * 20 } // Extruder
|
|||
#endif |
|||
}; |
|||
static const temp_calib_t cali_info[TSI_COUNT]; |
|||
|
|||
// Where to park nozzle to wait for probe cooldown
|
|||
static constexpr xyz_pos_t park_point = { PTC_PARK_POS_X, PTC_PARK_POS_Y, PTC_PARK_POS_Z }; |
|||
|
|||
static constexpr int max_bed_temp = PTC_MAX_BED_TEMP, // Max temperature to avoid heating errors
|
|||
|
|||
// XY coordinates of nozzle for probing the bed
|
|||
measure_point_x = PTC_PROBE_POS_X, // X-coordinate to probe
|
|||
measure_point_y = PTC_PROBE_POS_Y, // Y-coordinate to probe
|
|||
//measure_point_x = 12.0f, // X-coordinate to probe on MK52 magnetic heatbed
|
|||
//measure_point_y = 7.3f, // Y-coordinate to probe on MK52 magnetic heatbed
|
|||
|
|||
probe_calib_bed_temp = max_bed_temp, // Bed temperature while calibrating probe
|
|||
bed_calib_probe_temp = 30; // Probe temperature while calibrating bed
|
|||
|
|||
static int16_t *sensor_z_offsets[TSI_COUNT], |
|||
z_offsets_probe[cali_info_init[TSI_PROBE].measurements], // (µm)
|
|||
z_offsets_bed[cali_info_init[TSI_BED].measurements]; // (µm)
|
|||
|
|||
#if ENABLED(USE_TEMP_EXT_COMPENSATION) |
|||
static int16_t z_offsets_ext[cali_info_init[TSI_EXT].measurements]; // (µm)
|
|||
#endif |
|||
|
|||
static inline void reset_index() { calib_idx = 0; }; |
|||
static inline uint8_t get_index() { return calib_idx; } |
|||
static void clear_offsets(const TempSensorID tsi); |
|||
static inline void clear_all_offsets() { |
|||
clear_offsets(TSI_BED); |
|||
clear_offsets(TSI_PROBE); |
|||
#if ENABLED(USE_TEMP_EXT_COMPENSATION) |
|||
clear_offsets(TSI_EXT); |
|||
#endif |
|||
} |
|||
static bool set_offset(const TempSensorID tsi, const uint8_t idx, const int16_t offset); |
|||
static void print_offsets(); |
|||
static void prepare_new_calibration(const float &init_meas_z); |
|||
static void push_back_new_measurement(const TempSensorID tsi, const float &meas_z); |
|||
static bool finish_calibration(const TempSensorID tsi); |
|||
static void compensate_measurement(const TempSensorID tsi, const float &temp, float &meas_z); |
|||
|
|||
private: |
|||
static uint8_t calib_idx; |
|||
|
|||
/**
|
|||
* Base value. Temperature compensation values will be deltas |
|||
* to this value, set at first probe. |
|||
*/ |
|||
static float init_measurement; |
|||
|
|||
static float get_offset_for_temperature(const TempSensorID tsi, const float &temp); |
|||
|
|||
/**
|
|||
* Fit a linear function in measured temperature offsets |
|||
* to allow generating values of higher temperatures. |
|||
*/ |
|||
static bool linear_regression(const TempSensorID tsi, float &k, float &d); |
|||
}; |
|||
|
|||
extern ProbeTempComp temp_comp; |
|||
@ -0,0 +1,407 @@ |
|||
/**
|
|||
* 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/>.
|
|||
* |
|||
*/ |
|||
|
|||
/**
|
|||
* G76_M871.cpp - Temperature calibration/compensation for z-probing |
|||
*/ |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
#if ENABLED(PROBE_TEMP_COMPENSATION) |
|||
|
|||
#include "../gcode.h" |
|||
#include "../../module/motion.h" |
|||
#include "../../module/planner.h" |
|||
#include "../../module/probe.h" |
|||
#include "../../feature/bedlevel/bedlevel.h" |
|||
#include "../../module/temperature.h" |
|||
#include "../../module/probe.h" |
|||
#include "../../feature/probe_temp_compensation.h" |
|||
|
|||
/**
|
|||
* G76: calibrate probe and/or bed temperature offsets |
|||
* Notes: |
|||
* - When calibrating probe, bed temperature is held constant. |
|||
* Compensation values are deltas to first probe measurement at probe temp. = 30°C. |
|||
* - When calibrating bed, probe temperature is held constant. |
|||
* Compensation values are deltas to first probe measurement at bed temp. = 60°C. |
|||
* - The hotend will not be heated at any time. |
|||
* - On my Prusa MK3S clone I put a piece of paper between the probe and the hotend |
|||
* so the hotend fan would not cool my probe constantly. Alternativly you could just |
|||
* make sure the fan is not running while running the calibration process. |
|||
* |
|||
* Probe calibration: |
|||
* - Moves probe to cooldown point. |
|||
* - Heats up bed to 100°C. |
|||
* - Moves probe to probing point (1mm above heatbed). |
|||
* - Waits until probe reaches target temperature (30°C). |
|||
* - Does a z-probing (=base value) and increases target temperature by 5°C. |
|||
* - Waits until probe reaches increased target temperature. |
|||
* - Does a z-probing (delta to base value will be a compensation value) and increases target temperature by 5°C. |
|||
* - Repeats last two steps until max. temperature reached or timeout (i.e. probe does not heat up any further). |
|||
* - Compensation values of higher temperatures will be extrapolated (using linear regression first). |
|||
* While this is not exact by any means it is still better than simply using the last compensation value. |
|||
* |
|||
* Bed calibration: |
|||
* - Moves probe to cooldown point. |
|||
* - Heats up bed to 60°C. |
|||
* - Moves probe to probing point (1mm above heatbed). |
|||
* - Waits until probe reaches target temperature (30°C). |
|||
* - Does a z-probing (=base value) and increases bed temperature by 5°C. |
|||
* - Moves probe to cooldown point. |
|||
* - Waits until probe is below 30°C and bed has reached target temperature. |
|||
* - Moves probe to probing point and waits until it reaches target temperature (30°C). |
|||
* - Does a z-probing (delta to base value will be a compensation value) and increases bed temperature by 5°C. |
|||
* - Repeats last four points until max. bed temperature reached (110°C) or timeout. |
|||
* - Compensation values of higher temperatures will be extrapolated (using linear regression first). |
|||
* While this is not exact by any means it is still better than simply using the last compensation value. |
|||
* |
|||
* G76 [B | P] |
|||
* - no flag - Both calibration procedures will be run. |
|||
* - `B` - Run bed temperature calibration. |
|||
* - `P` - Run probe temperature calibration. |
|||
*/ |
|||
void GcodeSuite::G76() { |
|||
// Check if heated bed is available and z-homing is done with probe
|
|||
#if TEMP_SENSOR_BED == 0 || !(HOMING_Z_WITH_PROBE) |
|||
return; |
|||
#endif |
|||
|
|||
#if ENABLED(BLTOUCH) |
|||
// Make sure any BLTouch error condition is cleared
|
|||
bltouch_command(BLTOUCH_RESET, BLTOUCH_RESET_DELAY); |
|||
set_bltouch_deployed(false); |
|||
#endif |
|||
|
|||
bool do_bed_cal = parser.boolval('B'), |
|||
do_probe_cal = parser.boolval('P'); |
|||
if (!do_bed_cal && !do_probe_cal) |
|||
do_bed_cal = do_probe_cal = true; |
|||
|
|||
// Synchronize with planner
|
|||
planner.synchronize(); |
|||
|
|||
// Report temperatures every second and handle heating timeouts
|
|||
millis_t next_temp_report = millis() + 1000; |
|||
|
|||
if (do_bed_cal || do_probe_cal) { |
|||
// Ensure park position is reachable
|
|||
if (!position_is_reachable(ProbeTempComp::park_point.x, ProbeTempComp::park_point.y) |
|||
|| !(WITHIN(ProbeTempComp::park_point.z, Z_MIN_POS - 0.001f, Z_MAX_POS + 0.001f)) |
|||
) { |
|||
SERIAL_ECHOLNPGM("!Park position unreachable - aborting."); |
|||
return; |
|||
} |
|||
// Ensure probe position is reachable
|
|||
destination.set( |
|||
temp_comp.measure_point_x - probe_offset.x, |
|||
temp_comp.measure_point_y - probe_offset.y |
|||
); |
|||
if (!position_is_reachable_by_probe(destination)) { |
|||
SERIAL_ECHOLNPGM("!Probe position unreachable - aborting."); |
|||
return; |
|||
} |
|||
|
|||
G28(true); |
|||
} |
|||
|
|||
/******************************************
|
|||
* Calibrate bed temperature offsets |
|||
******************************************/ |
|||
|
|||
if (do_bed_cal) { |
|||
|
|||
uint16_t target_bed = temp_comp.cali_info_init[TSI_BED].start_temp, |
|||
target_probe = temp_comp.bed_calib_probe_temp; |
|||
|
|||
SERIAL_ECHOLNPGM("Waiting for printer to cool down."); |
|||
while (thermalManager.degBed() > target_bed |
|||
|| thermalManager.degProbe() > target_probe |
|||
) { |
|||
idle( |
|||
#if ENABLED(ADVANCED_PAUSE_FEATURE) |
|||
true |
|||
#endif |
|||
); |
|||
const millis_t ms = millis(); |
|||
if (ELAPSED(ms, next_temp_report)) { |
|||
thermalManager.print_heater_states(active_extruder); |
|||
next_temp_report = ms + 1000; |
|||
} |
|||
} |
|||
|
|||
// Disable leveling so it won't mess with us
|
|||
#if HAS_LEVELING |
|||
set_bed_leveling_enabled(false); |
|||
#endif |
|||
|
|||
bool timeout = false; |
|||
while (true) { |
|||
thermalManager.setTargetBed(target_bed); |
|||
|
|||
SERIAL_ECHOLNPAIR("Target Bed: ", target_bed, "; Probe: ", target_probe); |
|||
|
|||
// Park nozzle
|
|||
do_blocking_move_to(ProbeTempComp::park_point.x, ProbeTempComp::park_point.y, ProbeTempComp::park_point.z); |
|||
|
|||
// Wait for heatbed to reach target temp and probe to cool below target temp
|
|||
SERIAL_ECHOLNPGM("Waiting for bed and probe to reach target temp."); |
|||
const millis_t probe_timeout_ms = millis() + 900UL * 1000UL; |
|||
while (fabs(thermalManager.degBed() - float(target_bed)) > 0.1 || thermalManager.degProbe() > target_probe) { |
|||
idle( |
|||
#if ENABLED(ADVANCED_PAUSE_FEATURE) |
|||
true |
|||
#endif |
|||
); |
|||
const millis_t ms = millis(); |
|||
if (ELAPSED(ms, next_temp_report)) { |
|||
thermalManager.print_heater_states(active_extruder); |
|||
next_temp_report = ms + 1000; |
|||
} |
|||
if (ELAPSED(ms, probe_timeout_ms)) { |
|||
SERIAL_ECHOLNPGM("!Bed heating timeout."); |
|||
timeout = true; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (timeout) break; |
|||
|
|||
// Move probe to probing point and wait for probe to reach target temp
|
|||
destination.set(temp_comp.measure_point_x, temp_comp.measure_point_y, 0.5); |
|||
do_blocking_move_to(destination.x, destination.y, destination.z); |
|||
SERIAL_ECHOLNPGM("Waiting for probe heating."); |
|||
while (thermalManager.degProbe() < target_probe) { |
|||
idle( |
|||
#if ENABLED(ADVANCED_PAUSE_FEATURE) |
|||
true |
|||
#endif |
|||
); |
|||
const millis_t ms = millis(); |
|||
if (ELAPSED(ms, next_temp_report)) { |
|||
thermalManager.print_heater_states(active_extruder); |
|||
next_temp_report = ms + 1000; |
|||
} |
|||
} |
|||
|
|||
// Raise nozzle before probing
|
|||
destination.z = 5.0; |
|||
do_blocking_move_to_z(destination.z); |
|||
|
|||
// Do a single probe
|
|||
remember_feedrate_scaling_off(); |
|||
const float measured_z = probe_at_point( |
|||
destination.x + probe_offset.x, |
|||
destination.y + probe_offset.y, |
|||
PROBE_PT_NONE |
|||
); |
|||
restore_feedrate_and_scaling(); |
|||
|
|||
if (isnan(measured_z)) { |
|||
SERIAL_ECHOLNPGM("!Received NAN measurement - aborting."); |
|||
break; |
|||
} |
|||
else |
|||
SERIAL_ECHOLNPAIR_F("Measured: ", measured_z); |
|||
|
|||
if (target_bed == temp_comp.cali_info_init[TSI_BED].start_temp) |
|||
temp_comp.prepare_new_calibration(measured_z); |
|||
else |
|||
temp_comp.push_back_new_measurement(TSI_BED, measured_z); |
|||
|
|||
target_bed += temp_comp.cali_info_init[TSI_BED].temp_res; |
|||
if (target_bed > temp_comp.max_bed_temp) break; |
|||
} |
|||
|
|||
SERIAL_ECHOLNPAIR("Retrieved measurements: ", temp_comp.get_index()); |
|||
if (temp_comp.finish_calibration(TSI_BED)) |
|||
SERIAL_ECHOLNPGM("Successfully calibrated bed."); |
|||
else |
|||
SERIAL_ECHOLNPGM("!Failed to calibrated bed - reset calibration values."); |
|||
|
|||
// Cleanup
|
|||
thermalManager.setTargetBed(0); |
|||
#if HAS_LEVELING |
|||
set_bed_leveling_enabled(true); |
|||
#endif |
|||
} // do_bed_cal
|
|||
|
|||
/********************************************
|
|||
* Calibrate probe temperature offsets |
|||
********************************************/ |
|||
|
|||
if (do_probe_cal) { |
|||
|
|||
// Park nozzle
|
|||
do_blocking_move_to(ProbeTempComp::park_point.x, ProbeTempComp::park_point.y, ProbeTempComp::park_point.z); |
|||
|
|||
// Initialize temperatures
|
|||
uint16_t target_bed = temp_comp.probe_calib_bed_temp, |
|||
target_probe = temp_comp.cali_info_init[TSI_BED].start_temp; |
|||
thermalManager.setTargetBed(target_bed); |
|||
SERIAL_ECHOLNPGM("Waiting for bed and probe temperature."); |
|||
while (fabs(thermalManager.degBed() - float(target_bed)) > 0.1f |
|||
|| thermalManager.degProbe() > target_probe |
|||
) { |
|||
idle( |
|||
#if ENABLED(ADVANCED_PAUSE_FEATURE) |
|||
true |
|||
#endif |
|||
); |
|||
const millis_t ms = millis(); |
|||
if (ELAPSED(ms, next_temp_report)) { |
|||
thermalManager.print_heater_states(active_extruder); |
|||
next_temp_report = ms + 1000; |
|||
} |
|||
} |
|||
|
|||
// Disable leveling so it won't mess with us
|
|||
#if HAS_LEVELING |
|||
set_bed_leveling_enabled(false); |
|||
#endif |
|||
|
|||
bool timeout = false; |
|||
while (true) { |
|||
// Move probe to probing point and wait for it to reach target temperature
|
|||
destination.set(temp_comp.measure_point_x, temp_comp.measure_point_y, 0.5); |
|||
do_blocking_move_to(destination); |
|||
|
|||
SERIAL_ECHOLNPAIR( |
|||
"Bed temp: ", target_bed, |
|||
"; Probe temp: ", target_probe, |
|||
" Waiting for probe heating." |
|||
); |
|||
|
|||
const millis_t probe_timeout_ms = millis() + 900UL * 1000UL; |
|||
while (thermalManager.degProbe() < target_probe) { |
|||
idle( |
|||
#if ENABLED(ADVANCED_PAUSE_FEATURE) |
|||
true |
|||
#endif |
|||
); |
|||
const millis_t ms = millis(); |
|||
if (ELAPSED(ms, next_temp_report)) { |
|||
thermalManager.print_heater_states(active_extruder); |
|||
next_temp_report = ms + 1000; |
|||
} |
|||
if (ELAPSED(ms, probe_timeout_ms)) { |
|||
SERIAL_ECHOLNPGM("!Probe heating aborted due to timeout."); |
|||
timeout = true; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (timeout) break; |
|||
|
|||
// Raise nozzle before probing
|
|||
destination.z = 5.0; |
|||
do_blocking_move_to_z(destination.z); |
|||
|
|||
// Do a single probe
|
|||
remember_feedrate_scaling_off(); |
|||
const float measured_z = probe_at_point( |
|||
destination.x + probe_offset.x, |
|||
destination.y + probe_offset.y, |
|||
PROBE_PT_NONE |
|||
); |
|||
restore_feedrate_and_scaling(); |
|||
|
|||
if (isnan(measured_z)) { |
|||
SERIAL_ECHOLNPGM("!Received NAN measurement - aborting."); |
|||
break; |
|||
} |
|||
else |
|||
SERIAL_ECHOLNPAIR_F("Measured: ", measured_z); |
|||
|
|||
if (target_probe == temp_comp.cali_info_init[TSI_BED].start_temp) |
|||
temp_comp.prepare_new_calibration(measured_z); |
|||
else |
|||
temp_comp.push_back_new_measurement(TSI_PROBE, measured_z); |
|||
|
|||
target_probe += temp_comp.cali_info_init[TSI_BED].temp_res; |
|||
if (target_probe > temp_comp.cali_info_init[TSI_BED].end_temp) break; |
|||
} |
|||
|
|||
SERIAL_ECHOLNPAIR("Retrieved measurements: ", temp_comp.get_index()); |
|||
if (temp_comp.finish_calibration(TSI_PROBE)) |
|||
SERIAL_ECHOLNPGM("Successfully calibrated probe."); |
|||
else |
|||
SERIAL_ECHOLNPGM("!Failed to calibrated probe."); |
|||
|
|||
// Cleanup
|
|||
thermalManager.setTargetBed(0); |
|||
#if HAS_LEVELING |
|||
set_bed_leveling_enabled(true); |
|||
#endif |
|||
|
|||
SERIAL_ECHOLNPGM("Final compensation values:"); |
|||
temp_comp.print_offsets(); |
|||
} // do_probe_cal
|
|||
} |
|||
|
|||
/**
|
|||
* M871: Report / reset temperature compensation offsets. |
|||
* Note: This does not affect values in EEPROM until M500. |
|||
* |
|||
* M871 [ R | B | P | E ] |
|||
* |
|||
* No Parameters - Print current offset values. |
|||
* |
|||
* Select only one of these flags: |
|||
* R - Reset all offsets to zero (i.e., disable compensation). |
|||
* B - Manually set offset for bed |
|||
* P - Manually set offset for probe |
|||
* E - Manually set offset for extruder |
|||
* |
|||
* With B, P, or E: |
|||
* I[index] - Index in the array |
|||
* V[value] - Adjustment in µm |
|||
*/ |
|||
void GcodeSuite::M871() { |
|||
|
|||
if (parser.seen('R')) { |
|||
// Reset z-probe offsets to factory defaults
|
|||
temp_comp.clear_all_offsets(); |
|||
SERIAL_ECHOLNPGM("Offsets reset to default."); |
|||
} |
|||
else if (parser.seen("BPE")) { |
|||
if (!parser.seenval('V')) return; |
|||
const int16_t val = parser.value_int(); |
|||
if (!parser.seenval('I')) return; |
|||
const int16_t idx = parser.value_int(); |
|||
const TempSensorID mod = (parser.seen('B') ? TSI_BED : |
|||
#if ENABLED(USE_TEMP_EXT_COMPENSATION) |
|||
parser.seen('E') ? TSI_EXT : |
|||
#endif |
|||
TSI_PROBE |
|||
); |
|||
if (idx > 0 && temp_comp.set_offset(mod, idx - 1, val)) |
|||
SERIAL_ECHOLNPAIR("Set value: ", val); |
|||
else |
|||
SERIAL_ECHOLNPGM("!Invalid index. Failed to set value (note: value at index 0 is constant)."); |
|||
|
|||
} |
|||
else // Print current Z-probe adjustments. Note: Values in EEPROM might differ.
|
|||
temp_comp.print_offsets(); |
|||
} |
|||
|
|||
#endif // PROBE_TEMP_COMPENSATION
|
|||
Loading…
Reference in new issue