diff --git a/klippy/extras/heaters.py b/klippy/extras/heaters.py index fcec44fcd..bfa06e6d3 100644 --- a/klippy/extras/heaters.py +++ b/klippy/extras/heaters.py @@ -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) diff --git a/klippy/extras/pid_calibrate.py b/klippy/extras/pid_calibrate.py index 206411672..f0d3f038f 100644 --- a/klippy/extras/pid_calibrate.py +++ b/klippy/extras/pid_calibrate.py @@ -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)