2016-03-25 01:19:46 -05:00
|
|
|
/**
|
2016-03-24 13:01:20 -05:00
|
|
|
* Marlin 3D Printer Firmware
|
|
|
|
* Copyright (C) 2016 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/>.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-03-25 01:19:46 -05:00
|
|
|
/**
|
2016-04-28 20:18:13 -05:00
|
|
|
* temperature.h - temperature controller
|
|
|
|
*/
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2015-04-02 07:10:14 -05:00
|
|
|
#ifndef TEMPERATURE_H
|
2015-10-03 01:08:58 -05:00
|
|
|
#define TEMPERATURE_H
|
2012-03-08 14:43:21 -06:00
|
|
|
|
|
|
|
#include "planner.h"
|
2016-07-26 00:43:50 -05:00
|
|
|
#include "thermistortables.h"
|
2016-04-28 20:18:13 -05:00
|
|
|
|
2016-08-02 21:36:58 -05:00
|
|
|
#include "MarlinConfig.h"
|
|
|
|
|
2016-07-31 19:49:34 -05:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2012-03-08 14:43:21 -06:00
|
|
|
#include "stepper.h"
|
|
|
|
#endif
|
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#ifndef SOFT_PWM_SCALE
|
|
|
|
#define SOFT_PWM_SCALE 0
|
|
|
|
#endif
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2016-07-09 21:47:11 -05:00
|
|
|
#if HOTENDS == 1
|
2016-07-28 16:51:18 -05:00
|
|
|
#define HOTEND_LOOP() const int8_t e = 0;
|
2016-07-09 23:11:17 -05:00
|
|
|
#define HOTEND_INDEX 0
|
|
|
|
#define EXTRUDER_IDX 0
|
2016-07-09 21:47:11 -05:00
|
|
|
#else
|
2016-07-09 23:11:17 -05:00
|
|
|
#define HOTEND_LOOP() for (int8_t e = 0; e < HOTENDS; e++)
|
|
|
|
#define HOTEND_INDEX e
|
|
|
|
#define EXTRUDER_IDX active_extruder
|
2016-07-09 21:47:11 -05:00
|
|
|
#endif
|
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
class Temperature {
|
2015-10-03 01:08:58 -05:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
public:
|
2014-08-06 19:30:57 -05:00
|
|
|
|
2016-07-06 10:50:41 -05:00
|
|
|
static float current_temperature[HOTENDS],
|
|
|
|
current_temperature_bed;
|
|
|
|
static int current_temperature_raw[HOTENDS],
|
|
|
|
target_temperature[HOTENDS],
|
|
|
|
current_temperature_bed_raw,
|
|
|
|
target_temperature_bed;
|
2013-11-27 19:23:06 -06:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2016-05-26 13:58:38 -05:00
|
|
|
static float redundant_temperature;
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
2016-04-27 20:06:32 -05:00
|
|
|
|
2016-09-24 00:51:21 -05:00
|
|
|
static uint8_t soft_pwm_bed;
|
2015-01-10 20:50:17 -06:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
2016-09-24 00:51:21 -05:00
|
|
|
static uint8_t fanSpeedSoftPwm[FAN_COUNT];
|
2016-04-16 21:19:40 -05:00
|
|
|
#endif
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
#if ENABLED(PIDTEMP) || ENABLED(PIDTEMPBED)
|
|
|
|
#define PID_dT ((OVERSAMPLENR * 12.0)/(F_CPU / 64.0 / 256.0))
|
2016-04-16 21:19:40 -05:00
|
|
|
#endif
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
2015-04-03 18:38:05 -05:00
|
|
|
|
2016-07-12 00:08:14 -05:00
|
|
|
#if ENABLED(PID_PARAMS_PER_HOTEND) && HOTENDS > 1
|
2015-10-03 01:08:58 -05:00
|
|
|
|
2016-05-26 19:43:20 -05:00
|
|
|
static float Kp[HOTENDS], Ki[HOTENDS], Kd[HOTENDS];
|
2016-07-31 19:49:34 -05:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2016-05-26 19:43:20 -05:00
|
|
|
static float Kc[HOTENDS];
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
2016-07-12 00:08:14 -05:00
|
|
|
#define PID_PARAM(param, h) Temperature::param[h]
|
2015-10-03 01:08:58 -05:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#else
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
static float Kp, Ki, Kd;
|
2016-07-31 19:49:34 -05:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2016-04-28 20:18:13 -05:00
|
|
|
static float Kc;
|
|
|
|
#endif
|
2016-07-12 00:08:14 -05:00
|
|
|
#define PID_PARAM(param, h) Temperature::param
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2016-05-26 19:43:20 -05:00
|
|
|
#endif // PID_PARAMS_PER_HOTEND
|
2013-10-12 08:41:23 -05:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
// Apply the scale factors to the PID values
|
|
|
|
#define scalePID_i(i) ( (i) * PID_dT )
|
|
|
|
#define unscalePID_i(i) ( (i) / PID_dT )
|
|
|
|
#define scalePID_d(d) ( (d) / PID_dT )
|
|
|
|
#define unscalePID_d(d) ( (d) * PID_dT )
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
2015-05-21 14:07:37 -05:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2016-05-26 13:58:38 -05:00
|
|
|
static float bedKp, bedKi, bedKd;
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
2016-04-15 11:27:18 -05:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(BABYSTEPPING)
|
2016-05-26 13:58:38 -05:00
|
|
|
static volatile int babystepsTodo[3];
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0
|
2016-05-26 19:43:20 -05:00
|
|
|
static int watch_target_temp[HOTENDS];
|
|
|
|
static millis_t watch_heater_next_ms[HOTENDS];
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2016-06-21 04:13:41 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0
|
2016-05-26 13:58:38 -05:00
|
|
|
static int watch_target_bed_temp;
|
|
|
|
static millis_t watch_bed_next_ms;
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
2016-08-20 23:34:24 -05:00
|
|
|
#if ENABLED(PREVENT_COLD_EXTRUSION)
|
2016-07-06 10:28:09 -05:00
|
|
|
static bool allow_cold_extrude;
|
2016-05-26 13:58:38 -05:00
|
|
|
static float extrude_min_temp;
|
2016-07-09 21:47:11 -05:00
|
|
|
static bool tooColdToExtrude(uint8_t e) {
|
|
|
|
#if HOTENDS == 1
|
|
|
|
UNUSED(e);
|
|
|
|
#endif
|
2016-07-06 10:28:09 -05:00
|
|
|
return allow_cold_extrude ? false : degHotend(HOTEND_INDEX) < extrude_min_temp;
|
2016-07-09 21:47:11 -05:00
|
|
|
}
|
2016-04-28 20:18:13 -05:00
|
|
|
#else
|
2016-05-30 19:06:50 -05:00
|
|
|
static bool tooColdToExtrude(uint8_t e) { UNUSED(e); return false; }
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2016-05-26 13:58:38 -05:00
|
|
|
static int redundant_temperature_raw;
|
|
|
|
static float redundant_temperature;
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
2016-05-26 13:58:38 -05:00
|
|
|
static volatile bool temp_meas_ready;
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
#if ENABLED(PIDTEMP)
|
2016-07-06 10:50:41 -05:00
|
|
|
static float temp_iState[HOTENDS],
|
|
|
|
temp_dState[HOTENDS],
|
|
|
|
pTerm[HOTENDS],
|
|
|
|
iTerm[HOTENDS],
|
|
|
|
dTerm[HOTENDS];
|
2016-04-28 20:18:13 -05:00
|
|
|
|
2016-07-31 19:49:34 -05:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2016-05-26 19:43:20 -05:00
|
|
|
static float cTerm[HOTENDS];
|
2016-07-12 00:06:44 -05:00
|
|
|
static long last_e_position;
|
2016-05-26 13:58:38 -05:00
|
|
|
static long lpq[LPQ_MAX_LEN];
|
|
|
|
static int lpq_ptr;
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
2016-09-28 02:26:49 -05:00
|
|
|
static float pid_error[HOTENDS];
|
2016-05-26 19:43:20 -05:00
|
|
|
static bool pid_reset[HOTENDS];
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(PIDTEMPBED)
|
2016-07-06 10:50:41 -05:00
|
|
|
static float temp_iState_bed,
|
|
|
|
temp_dState_bed,
|
|
|
|
pTerm_bed,
|
|
|
|
iTerm_bed,
|
|
|
|
dTerm_bed,
|
2016-09-28 02:26:49 -05:00
|
|
|
pid_error_bed;
|
2016-04-28 20:18:13 -05:00
|
|
|
#else
|
2016-05-26 13:58:38 -05:00
|
|
|
static millis_t next_bed_check_ms;
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
2015-03-29 18:58:46 -05:00
|
|
|
|
2016-07-06 10:50:41 -05:00
|
|
|
static unsigned long raw_temp_value[4],
|
|
|
|
raw_temp_bed_value;
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
// Init min and max temp with extreme values to prevent false errors during startup
|
2016-07-06 10:50:41 -05:00
|
|
|
static int minttemp_raw[HOTENDS],
|
|
|
|
maxttemp_raw[HOTENDS],
|
|
|
|
minttemp[HOTENDS],
|
|
|
|
maxttemp[HOTENDS];
|
2016-04-28 20:18:13 -05:00
|
|
|
|
2016-07-08 21:28:37 -05:00
|
|
|
#ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
|
|
|
|
static int consecutive_low_temperature_error[HOTENDS];
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef MILLISECONDS_PREHEAT_TIME
|
|
|
|
static unsigned long preheat_end_time[HOTENDS];
|
|
|
|
#endif
|
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#ifdef BED_MINTEMP
|
2016-05-26 13:58:38 -05:00
|
|
|
static int bed_minttemp_raw;
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef BED_MAXTEMP
|
2016-05-26 13:58:38 -05:00
|
|
|
static int bed_maxttemp_raw;
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(FILAMENT_WIDTH_SENSOR)
|
2016-05-26 13:58:38 -05:00
|
|
|
static int meas_shift_index; // Index of a delayed sample in buffer
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_AUTO_FAN
|
2016-05-26 13:58:38 -05:00
|
|
|
static millis_t next_auto_fan_check_ms;
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
2016-09-24 00:51:21 -05:00
|
|
|
static uint8_t soft_pwm[HOTENDS];
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
2016-09-24 00:51:21 -05:00
|
|
|
static uint8_t soft_pwm_fan[FAN_COUNT];
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
2014-06-30 13:22:37 -05:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(FILAMENT_WIDTH_SENSOR)
|
2016-05-26 13:58:38 -05:00
|
|
|
static int current_raw_filwidth; //Holds measured filament diameter - one extruder only
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Instance Methods
|
|
|
|
*/
|
|
|
|
|
|
|
|
Temperature();
|
|
|
|
|
|
|
|
void init();
|
|
|
|
|
2016-05-26 13:58:38 -05:00
|
|
|
/**
|
|
|
|
* Static (class) methods
|
|
|
|
*/
|
|
|
|
static float analog2temp(int raw, uint8_t e);
|
|
|
|
static float analog2tempBed(int raw);
|
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
/**
|
|
|
|
* Called from the Temperature ISR
|
|
|
|
*/
|
2016-05-26 13:58:38 -05:00
|
|
|
static void isr();
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Call periodically to manage heaters
|
|
|
|
*/
|
2016-05-26 13:58:38 -05:00
|
|
|
static void manage_heater();
|
2016-04-28 20:18:13 -05:00
|
|
|
|
2016-07-08 21:28:37 -05:00
|
|
|
/**
|
|
|
|
* Preheating hotends
|
|
|
|
*/
|
|
|
|
#ifdef MILLISECONDS_PREHEAT_TIME
|
2016-07-12 00:08:47 -05:00
|
|
|
static bool is_preheating(uint8_t e) {
|
|
|
|
#if HOTENDS == 1
|
|
|
|
UNUSED(e);
|
|
|
|
#endif
|
|
|
|
return preheat_end_time[HOTEND_INDEX] && PENDING(millis(), preheat_end_time[HOTEND_INDEX]);
|
|
|
|
}
|
|
|
|
static void start_preheat_time(uint8_t e) {
|
|
|
|
#if HOTENDS == 1
|
|
|
|
UNUSED(e);
|
|
|
|
#endif
|
|
|
|
preheat_end_time[HOTEND_INDEX] = millis() + MILLISECONDS_PREHEAT_TIME;
|
|
|
|
}
|
|
|
|
static void reset_preheat_time(uint8_t e) {
|
|
|
|
#if HOTENDS == 1
|
|
|
|
UNUSED(e);
|
|
|
|
#endif
|
|
|
|
preheat_end_time[HOTEND_INDEX] = 0;
|
2016-07-08 21:28:37 -05:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define is_preheating(n) (false)
|
|
|
|
#endif
|
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(FILAMENT_WIDTH_SENSOR)
|
2016-05-26 13:58:38 -05:00
|
|
|
static float analog2widthFil(); // Convert raw Filament Width to millimeters
|
|
|
|
static int widthFil_to_size_ratio(); // Convert raw Filament Width to an extrusion ratio
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
//high level conversion routines, for use outside of temperature.cpp
|
|
|
|
//inline so that there is no performance decrease.
|
|
|
|
//deg=degreeCelsius
|
|
|
|
|
2016-07-09 23:11:17 -05:00
|
|
|
static float degHotend(uint8_t e) {
|
2016-05-26 19:43:20 -05:00
|
|
|
#if HOTENDS == 1
|
2016-07-09 23:11:17 -05:00
|
|
|
UNUSED(e);
|
2016-05-26 19:43:20 -05:00
|
|
|
#endif
|
2016-07-09 23:11:17 -05:00
|
|
|
return current_temperature[HOTEND_INDEX];
|
2016-05-26 19:43:20 -05:00
|
|
|
}
|
2016-05-30 19:06:50 -05:00
|
|
|
static float degBed() { return current_temperature_bed; }
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
2016-07-09 23:11:17 -05:00
|
|
|
static float rawHotendTemp(uint8_t e) {
|
2016-05-26 19:43:20 -05:00
|
|
|
#if HOTENDS == 1
|
2016-07-09 23:11:17 -05:00
|
|
|
UNUSED(e);
|
2016-05-26 19:43:20 -05:00
|
|
|
#endif
|
2016-07-09 23:11:17 -05:00
|
|
|
return current_temperature_raw[HOTEND_INDEX];
|
2016-05-26 19:43:20 -05:00
|
|
|
}
|
2016-05-30 19:06:50 -05:00
|
|
|
static float rawBedTemp() { return current_temperature_bed_raw; }
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
2016-07-09 23:11:17 -05:00
|
|
|
static float degTargetHotend(uint8_t e) {
|
2016-05-26 19:43:20 -05:00
|
|
|
#if HOTENDS == 1
|
2016-07-09 23:11:17 -05:00
|
|
|
UNUSED(e);
|
2016-05-26 19:43:20 -05:00
|
|
|
#endif
|
2016-07-09 23:11:17 -05:00
|
|
|
return target_temperature[HOTEND_INDEX];
|
2016-05-26 19:43:20 -05:00
|
|
|
}
|
2016-05-30 19:06:50 -05:00
|
|
|
static float degTargetBed() { return target_temperature_bed; }
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0
|
2016-07-09 23:11:17 -05:00
|
|
|
static void start_watching_heater(uint8_t e = 0);
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0
|
2016-05-26 13:58:38 -05:00
|
|
|
static void start_watching_bed();
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
2016-07-09 23:11:17 -05:00
|
|
|
static void setTargetHotend(const float& celsius, uint8_t e) {
|
2016-05-26 19:43:20 -05:00
|
|
|
#if HOTENDS == 1
|
2016-07-09 23:11:17 -05:00
|
|
|
UNUSED(e);
|
2016-05-26 19:43:20 -05:00
|
|
|
#endif
|
2016-07-08 21:28:37 -05:00
|
|
|
#ifdef MILLISECONDS_PREHEAT_TIME
|
|
|
|
if (celsius == 0.0f)
|
2016-07-12 00:07:43 -05:00
|
|
|
reset_preheat_time(HOTEND_INDEX);
|
|
|
|
else if (target_temperature[HOTEND_INDEX] == 0.0f)
|
|
|
|
start_preheat_time(HOTEND_INDEX);
|
2016-07-08 21:28:37 -05:00
|
|
|
#endif
|
2016-07-09 23:11:17 -05:00
|
|
|
target_temperature[HOTEND_INDEX] = celsius;
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0
|
2016-07-09 23:11:17 -05:00
|
|
|
start_watching_heater(HOTEND_INDEX);
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-05-30 19:06:50 -05:00
|
|
|
static void setTargetBed(const float& celsius) {
|
2016-04-28 20:18:13 -05:00
|
|
|
target_temperature_bed = celsius;
|
|
|
|
#if ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0
|
|
|
|
start_watching_bed();
|
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
}
|
2016-04-28 20:18:13 -05:00
|
|
|
|
2016-07-09 23:11:17 -05:00
|
|
|
static bool isHeatingHotend(uint8_t e) {
|
2016-05-26 19:43:20 -05:00
|
|
|
#if HOTENDS == 1
|
2016-07-09 23:11:17 -05:00
|
|
|
UNUSED(e);
|
2016-05-26 19:43:20 -05:00
|
|
|
#endif
|
2016-07-09 23:11:17 -05:00
|
|
|
return target_temperature[HOTEND_INDEX] > current_temperature[HOTEND_INDEX];
|
2016-05-26 19:43:20 -05:00
|
|
|
}
|
2016-05-30 19:06:50 -05:00
|
|
|
static bool isHeatingBed() { return target_temperature_bed > current_temperature_bed; }
|
2016-04-28 20:18:13 -05:00
|
|
|
|
2016-07-09 23:11:17 -05:00
|
|
|
static bool isCoolingHotend(uint8_t e) {
|
2016-05-26 19:43:20 -05:00
|
|
|
#if HOTENDS == 1
|
2016-07-09 23:11:17 -05:00
|
|
|
UNUSED(e);
|
2016-05-26 19:43:20 -05:00
|
|
|
#endif
|
2016-07-09 23:11:17 -05:00
|
|
|
return target_temperature[HOTEND_INDEX] < current_temperature[HOTEND_INDEX];
|
2016-05-26 19:43:20 -05:00
|
|
|
}
|
2016-05-30 19:06:50 -05:00
|
|
|
static bool isCoolingBed() { return target_temperature_bed < current_temperature_bed; }
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The software PWM power for a heater
|
|
|
|
*/
|
2016-05-26 13:58:38 -05:00
|
|
|
static int getHeaterPower(int heater);
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Switch off all heaters, set all target temperatures to 0
|
|
|
|
*/
|
2016-05-26 13:58:38 -05:00
|
|
|
static void disable_all_heaters();
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Perform auto-tuning for hotend or bed in response to M303
|
|
|
|
*/
|
|
|
|
#if HAS_PID_HEATING
|
2016-05-26 19:43:20 -05:00
|
|
|
static void PID_autotune(float temp, int hotend, int ncycles, bool set_result=false);
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Update the temp manager when PID values change
|
|
|
|
*/
|
2016-05-26 13:58:38 -05:00
|
|
|
static void updatePID();
|
2016-04-28 20:18:13 -05:00
|
|
|
|
2016-05-30 19:06:50 -05:00
|
|
|
static void autotempShutdown() {
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(AUTOTEMP)
|
|
|
|
if (planner.autotemp_enabled) {
|
|
|
|
planner.autotemp_enabled = false;
|
2016-07-09 23:11:17 -05:00
|
|
|
if (degTargetHotend(EXTRUDER_IDX) > planner.autotemp_min)
|
|
|
|
setTargetHotend(0, EXTRUDER_IDX);
|
2016-04-28 20:18:13 -05:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-05-05 16:57:24 -05:00
|
|
|
#if ENABLED(BABYSTEPPING)
|
|
|
|
|
2016-05-30 19:06:50 -05:00
|
|
|
static void babystep_axis(AxisEnum axis, int distance) {
|
2016-05-20 15:27:49 -05:00
|
|
|
#if ENABLED(COREXY) || ENABLED(COREXZ) || ENABLED(COREYZ)
|
2016-05-05 16:57:24 -05:00
|
|
|
#if ENABLED(BABYSTEP_XY)
|
|
|
|
switch (axis) {
|
2016-05-20 15:27:49 -05:00
|
|
|
case CORE_AXIS_1: // X on CoreXY and CoreXZ, Y on CoreYZ
|
|
|
|
babystepsTodo[CORE_AXIS_1] += distance * 2;
|
2016-05-05 16:57:24 -05:00
|
|
|
babystepsTodo[CORE_AXIS_2] += distance * 2;
|
|
|
|
break;
|
2016-05-20 15:27:49 -05:00
|
|
|
case CORE_AXIS_2: // Y on CoreXY, Z on CoreXZ and CoreYZ
|
|
|
|
babystepsTodo[CORE_AXIS_1] += distance * 2;
|
2016-05-05 16:57:24 -05:00
|
|
|
babystepsTodo[CORE_AXIS_2] -= distance * 2;
|
|
|
|
break;
|
2016-05-20 15:32:30 -05:00
|
|
|
case NORMAL_AXIS: // Z on CoreXY, Y on CoreXZ, X on CoreYZ
|
|
|
|
babystepsTodo[NORMAL_AXIS] += distance;
|
2016-05-05 16:57:24 -05:00
|
|
|
break;
|
|
|
|
}
|
2016-05-20 15:27:49 -05:00
|
|
|
#elif ENABLED(COREXZ) || ENABLED(COREYZ)
|
|
|
|
// Only Z stepping needs to be handled here
|
|
|
|
babystepsTodo[CORE_AXIS_1] += distance * 2;
|
|
|
|
babystepsTodo[CORE_AXIS_2] -= distance * 2;
|
2016-05-05 16:57:24 -05:00
|
|
|
#else
|
|
|
|
babystepsTodo[Z_AXIS] += distance;
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
babystepsTodo[axis] += distance;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // BABYSTEPPING
|
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
private:
|
|
|
|
|
2016-05-26 13:58:38 -05:00
|
|
|
static void set_current_temp_raw();
|
2016-04-28 20:18:13 -05:00
|
|
|
|
2016-05-26 13:58:38 -05:00
|
|
|
static void updateTemperaturesFromRawValues();
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
#if ENABLED(HEATER_0_USES_MAX6675)
|
2016-05-26 13:58:38 -05:00
|
|
|
static int read_max6675();
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
2016-05-26 13:58:38 -05:00
|
|
|
static void checkExtruderAutoFans();
|
2016-04-28 20:18:13 -05:00
|
|
|
|
2016-05-26 13:58:38 -05:00
|
|
|
static float get_pid_output(int e);
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
#if ENABLED(PIDTEMPBED)
|
2016-05-26 13:58:38 -05:00
|
|
|
static float get_pid_output_bed();
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
2016-05-26 13:58:38 -05:00
|
|
|
static void _temp_error(int e, const char* serial_msg, const char* lcd_msg);
|
2016-08-09 00:21:01 -05:00
|
|
|
static void min_temp_error(int8_t e);
|
|
|
|
static void max_temp_error(int8_t e);
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS) || HAS_THERMALLY_PROTECTED_BED
|
|
|
|
|
2016-05-08 19:01:46 -05:00
|
|
|
typedef enum TRState { TRInactive, TRFirstHeating, TRStable, TRRunaway } TRstate;
|
2016-04-28 20:18:13 -05:00
|
|
|
|
2016-05-26 13:58:38 -05:00
|
|
|
static void thermal_runaway_protection(TRState* state, millis_t* timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc);
|
2016-04-28 20:18:13 -05:00
|
|
|
|
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS)
|
2016-05-26 19:43:20 -05:00
|
|
|
static TRState thermal_runaway_state_machine[HOTENDS];
|
|
|
|
static millis_t thermal_runaway_timer[HOTENDS];
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_THERMALLY_PROTECTED_BED
|
2016-05-26 13:58:38 -05:00
|
|
|
static TRState thermal_runaway_bed_state_machine;
|
|
|
|
static millis_t thermal_runaway_bed_timer;
|
2016-04-28 20:18:13 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif // THERMAL_PROTECTION
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
extern Temperature thermalManager;
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2015-04-02 07:10:14 -05:00
|
|
|
#endif // TEMPERATURE_H
|