3D-printing/klipper
1
0
Fork 0
mirror of https://github.com/Klipper3d/klipper.git synced 2025-12-24 00:28:34 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Merge c6dbbaa45c into 8b58aa1302

Browse source
This commit is contained in:
David van 't Wout 2025-12-22 17:32:58 +01:00 • committed by GitHub
commit cb62eadb38
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 50 additions and 25 deletions
Download patch file Download diff file Expand all files Collapse all files

47
klippy/extras/heaters.py
View file

@ -4,6 +4,7 @@
#
# This file may be distributed under the terms of the GNU GPLv3 license.
import os, logging, threading
from math import ceil
######################################################################
@ -46,6 +47,8 @@ class Heater:
# pwm caching
self.next_pwm_time = 0.
self.last_pwm_value = 0.
self._last_pwm_time = 0.
self._last_control_time = 0.
# Setup control algorithm sub-class
algos = {'watermark': ControlBangBang, 'pid': ControlPID}
algo = config.getchoice('control', algos)
@ -54,9 +57,9 @@ class Heater:
heater_pin = config.get('heater_pin')
ppins = self.printer.lookup_object('pins')
self.mcu_pwm = ppins.setup_pin('pwm', heater_pin)
pwm_cycle_time = config.getfloat('pwm_cycle_time', 0.100, above=0.,
maxval=self.pwm_delay)
self.mcu_pwm.setup_cycle_time(pwm_cycle_time)
self._pwm_cycle_time = config.getfloat(
'pwm_cycle_time', 0.100, above=0., maxval=MAX_HEAT_TIME)
self.mcu_pwm.setup_cycle_time(self._pwm_cycle_time)
self.mcu_pwm.setup_max_duration(MAX_HEAT_TIME)
# Load additional modules
self.printer.load_object(config, "verify_heater %s" % (short_name,))
@ -75,9 +78,17 @@ class Heater:
# No significant change in value - can suppress update
return
pwm_time = read_time + self.pwm_delay
self.next_pwm_time = (pwm_time + MAX_HEAT_TIME
- (3. * self.pwm_delay + 0.001))
self.next_pwm_time = (pwm_time + MAX_HEAT_TIME -
(3. * self.pwm_delay +
self._pwm_cycle_time + 0.001))
self.last_pwm_value = value
if self._last_pwm_time and self.last_pwm_value < pwm_time:
delta_pwm_time = pwm_time - self._last_pwm_time
cycles = ceil(round(delta_pwm_time / self._pwm_cycle_time, 3))
if not cycles:
return
pwm_time = self._last_pwm_time + cycles * self._pwm_cycle_time
self._last_pwm_time = pwm_time
self.mcu_pwm.set_pwm(pwm_time, value)
#logging.debug("%s: pwm=%.3f@%.3f (from %.3f@%.3f [%.3f])",
# self.name, value, pwm_time,
@ -87,12 +98,17 @@ class Heater:
time_diff = read_time - self.last_temp_time
self.last_temp = temp
self.last_temp_time = read_time
self.control.temperature_update(read_time, temp, self.target_temp)
next_read_time = read_time + self.sensor.get_report_time_delta()
next_control_time = self._last_control_time + self._pwm_cycle_time
if next_read_time > next_control_time:
self._last_control_time = read_time
pwm_value = self.control.temperature_update(
read_time, temp, self.target_temp)
self.set_pwm(read_time, pwm_value)
temp_diff = temp - self.smoothed_temp
adj_time = min(time_diff * self.inv_smooth_time, 1.)
self.smoothed_temp += temp_diff * adj_time
self.can_extrude = (self.smoothed_temp >= self.min_extrude_temp)
#logging.debug("temp: %.3f %f = %f", read_time, temp)
def _handle_shutdown(self):
self.verify_mainthread_time = -999.
# External commands
@ -120,8 +136,7 @@ class Heater:
return self.smoothed_temp, self.target_temp
def check_busy(self, eventtime):
with self.lock:
return self.control.check_busy(
eventtime, self.smoothed_temp, self.target_temp)
return self.control.check_busy(self.smoothed_temp, self.target_temp)
def set_control(self, control):
with self.lock:
old_control = self.control
@ -167,16 +182,18 @@ class ControlBangBang:
self.heater_max_power = heater.get_max_power()
self.max_delta = config.getfloat('max_delta', 2.0, above=0.)
self.heating = False
def temperature_update(self, read_time, temp, target_temp):
if self.heating and temp >= target_temp+self.max_delta:
self.heating = False
elif not self.heating and temp <= target_temp-self.max_delta:
self.heating = True
if self.heating:
self.heater.set_pwm(read_time, self.heater_max_power)
return self.heater_max_power
else:
self.heater.set_pwm(read_time, 0.)
def check_busy(self, eventtime, smoothed_temp, target_temp):
return 0.
def check_busy(self, smoothed_temp, target_temp):
return smoothed_temp < target_temp-self.max_delta
@ -202,6 +219,7 @@ class ControlPID:
self.prev_temp_time = 0.
self.prev_temp_deriv = 0.
self.prev_temp_integ = 0.
def temperature_update(self, read_time, temp, target_temp):
time_diff = read_time - self.prev_temp_time
# Calculate change of temperature
@ -220,14 +238,15 @@ class ControlPID:
#logging.debug("pid: %f@%.3f -> diff=%f deriv=%f err=%f integ=%f co=%d",
# temp, read_time, temp_diff, temp_deriv, temp_err, temp_integ, co)
bounded_co = max(0., min(self.heater_max_power, co))
self.heater.set_pwm(read_time, bounded_co)
# Store state for next measurement
self.prev_temp = temp
self.prev_temp_time = read_time
self.prev_temp_deriv = temp_deriv
if co == bounded_co:
self.prev_temp_integ = temp_integ
def check_busy(self, eventtime, smoothed_temp, target_temp):
return bounded_co
def check_busy(self, smoothed_temp, target_temp):
temp_diff = target_temp - smoothed_temp
return (abs(temp_diff) > PID_SETTLE_DELTA
or abs(self.prev_temp_deriv) > PID_SETTLE_SLOPE)

28
klippy/extras/pid_calibrate.py
View file

@ -12,6 +12,7 @@ class PIDCalibrate:
gcode = self.printer.lookup_object('gcode')
gcode.register_command('PID_CALIBRATE', self.cmd_PID_CALIBRATE,
desc=self.cmd_PID_CALIBRATE_help)
cmd_PID_CALIBRATE_help = "Run PID calibration test"
def cmd_PID_CALIBRATE(self, gcmd):
heater_name = gcmd.get('HEATER')
@ -33,7 +34,7 @@ class PIDCalibrate:
heater.set_control(old_control)
if write_file:
calibrate.write_file('/tmp/heattest.txt')
if calibrate.check_busy(0., 0., 0.):
if calibrate.check_busy( 0., 0.):
raise gcmd.error("pid_calibrate interrupted")
# Log and report results
Kp, Ki, Kd = calibrate.calc_final_pid()
@ -50,6 +51,7 @@ class PIDCalibrate:
configfile.set(cfgname, 'pid_Ki', "%.3f" % (Ki,))
configfile.set(cfgname, 'pid_Kd', "%.3f" % (Kd,))
TUNE_PID_DELTA = 5.0
class ControlAutoTune:
@ -67,13 +69,7 @@ class ControlAutoTune:
self.last_pwm = 0.
self.pwm_samples = []
self.temp_samples = []
# Heater control
def set_pwm(self, read_time, value):
if value != self.last_pwm:
self.pwm_samples.append(
(read_time + self.heater.get_pwm_delay(), value))
self.last_pwm = value
self.heater.set_pwm(read_time, value)
def temperature_update(self, read_time, temp, target_temp):
self.temp_samples.append((read_time, temp))
# Check if the temperature has crossed the target and
@ -88,19 +84,26 @@ class ControlAutoTune:
self.heater.alter_target(self.calibrate_temp)
# Check if this temperature is a peak and record it if so
if self.heating:
self.set_pwm(read_time, self.heater_max_power)
pwm_value = self.heater_max_power
if temp < self.peak:
self.peak = temp
self.peak_time = read_time
else:
self.set_pwm(read_time, 0.)
pwm_value = 0.
if temp > self.peak:
self.peak = temp
self.peak_time = read_time
def check_busy(self, eventtime, smoothed_temp, target_temp):
if pwm_value != self.last_pwm:
self.pwm_samples.append(
(read_time + self.heater.get_pwm_delay(), pwm_value))
self.last_pwm = pwm_value
return pwm_value
def check_busy(self, smoothed_temp, target_temp):
if self.heating or len(self.peaks) < 12:
return True
return False
# Analysis
def check_peaks(self):
self.peaks.append((self.peak, self.peak_time))
@ -111,6 +114,7 @@ class ControlAutoTune:
if len(self.peaks) < 4:
return
self.calc_pid(len(self.peaks)-1)
def calc_pid(self, pos):
temp_diff = self.peaks[pos][0] - self.peaks[pos-1][0]
time_diff = self.peaks[pos][1] - self.peaks[pos-2][1]
@ -127,11 +131,13 @@ class ControlAutoTune:
logging.info("Autotune: raw=%f/%f Ku=%f Tu=%f Kp=%f Ki=%f Kd=%f",
temp_diff, self.heater_max_power, Ku, Tu, Kp, Ki, Kd)
return Kp, Ki, Kd
def calc_final_pid(self):
cycle_times = [(self.peaks[pos][1] - self.peaks[pos-2][1], pos)
for pos in range(4, len(self.peaks))]
midpoint_pos = sorted(cycle_times)[len(cycle_times)//2][1]
return self.calc_pid(midpoint_pos)
# Offline analysis helper
def write_file(self, filename):
pwm = ["pwm: %.3f %.3f" % (time, value)