2016-03-25 06:19:46 +00:00
|
|
|
/**
|
2016-03-24 18:01:20 +00:00
|
|
|
* Marlin 3D Printer Firmware
|
2020-02-03 14:00:57 +00:00
|
|
|
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
2016-03-24 18:01:20 +00:00
|
|
|
*
|
|
|
|
* Based on Sprinter and grbl.
|
2019-06-28 04:57:50 +00:00
|
|
|
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
|
2016-03-24 18:01:20 +00:00
|
|
|
*
|
|
|
|
* 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
|
2020-07-23 03:20:14 +00:00
|
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
2016-03-24 18:01:20 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-03-25 06:19:46 +00:00
|
|
|
/**
|
2016-04-29 01:18:13 +00:00
|
|
|
* temperature.cpp - temperature control
|
|
|
|
*/
|
2011-12-22 11:38:50 +00:00
|
|
|
|
2020-07-11 05:23:48 +00:00
|
|
|
// Useful when debugging thermocouples
|
|
|
|
//#define IGNORE_THERMOCOUPLE_ERRORS
|
|
|
|
|
2011-11-15 21:50:43 +00:00
|
|
|
#include "temperature.h"
|
2018-05-09 05:17:53 +00:00
|
|
|
#include "endstops.h"
|
2017-09-06 11:28:32 +00:00
|
|
|
|
2020-01-03 01:01:38 +00:00
|
|
|
#include "../MarlinCore.h"
|
2017-05-04 01:43:00 +00:00
|
|
|
#include "planner.h"
|
2018-08-14 08:28:52 +00:00
|
|
|
#include "../HAL/shared/Delay.h"
|
2020-04-27 09:35:20 +00:00
|
|
|
|
|
|
|
#include "../lcd/ultralcd.h"
|
2020-06-16 06:45:27 +00:00
|
|
|
|
|
|
|
#if ENABLED(DWIN_CREALITY_LCD)
|
2020-09-07 02:40:58 +00:00
|
|
|
#include "../lcd/dwin/e3v2/dwin.h"
|
2020-06-16 06:45:27 +00:00
|
|
|
#endif
|
|
|
|
|
2020-01-04 03:00:44 +00:00
|
|
|
#if ENABLED(EXTENSIBLE_UI)
|
2020-03-13 21:29:29 +00:00
|
|
|
#include "../lcd/extui/ui_api.h"
|
2020-01-04 03:00:44 +00:00
|
|
|
#endif
|
2017-04-15 15:22:42 +00:00
|
|
|
|
2019-11-21 09:15:10 +00:00
|
|
|
#if ENABLED(MAX6675_IS_MAX31865)
|
2020-04-02 04:50:08 +00:00
|
|
|
#include <Adafruit_MAX31865.h>
|
2019-11-21 09:15:10 +00:00
|
|
|
#ifndef MAX31865_CS_PIN
|
2019-11-27 07:45:03 +00:00
|
|
|
#define MAX31865_CS_PIN MAX6675_SS_PIN // HW:49 SW:65 for example
|
2019-11-21 09:15:10 +00:00
|
|
|
#endif
|
|
|
|
#ifndef MAX31865_MOSI_PIN
|
2019-11-27 07:45:03 +00:00
|
|
|
#define MAX31865_MOSI_PIN MOSI_PIN // 63
|
2019-11-21 09:15:10 +00:00
|
|
|
#endif
|
|
|
|
#ifndef MAX31865_MISO_PIN
|
2019-11-27 07:45:03 +00:00
|
|
|
#define MAX31865_MISO_PIN MAX6675_DO_PIN // 42
|
2019-11-21 09:15:10 +00:00
|
|
|
#endif
|
|
|
|
#ifndef MAX31865_SCK_PIN
|
2019-11-27 07:45:03 +00:00
|
|
|
#define MAX31865_SCK_PIN MAX6675_SCK_PIN // 40
|
2019-11-21 09:15:10 +00:00
|
|
|
#endif
|
|
|
|
Adafruit_MAX31865 max31865 = Adafruit_MAX31865(MAX31865_CS_PIN
|
2019-11-27 07:45:03 +00:00
|
|
|
#if MAX31865_CS_PIN != MAX6675_SS_PIN
|
2019-11-21 09:15:10 +00:00
|
|
|
, MAX31865_MOSI_PIN // For software SPI also set MOSI/MISO/SCK
|
|
|
|
, MAX31865_MISO_PIN
|
|
|
|
, MAX31865_SCK_PIN
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
#endif
|
|
|
|
|
2020-02-04 07:24:11 +00:00
|
|
|
#define MAX6675_SEPARATE_SPI (EITHER(HEATER_0_USES_MAX6675, HEATER_1_USES_MAX6675) && PINS_EXIST(MAX6675_SCK, MAX6675_DO))
|
2019-02-06 04:56:13 +00:00
|
|
|
|
|
|
|
#if MAX6675_SEPARATE_SPI
|
2017-09-06 11:28:32 +00:00
|
|
|
#include "../libs/private_spi.h"
|
2017-04-15 15:22:42 +00:00
|
|
|
#endif
|
|
|
|
|
2020-02-14 11:14:37 +00:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2016-08-02 19:05:31 +00:00
|
|
|
#include "stepper.h"
|
|
|
|
#endif
|
2015-01-15 23:52:10 +00:00
|
|
|
|
2020-02-16 03:42:28 +00:00
|
|
|
#if ENABLED(BABYSTEPPING) && DISABLED(INTEGRATED_BABYSTEPPING)
|
2019-04-06 23:04:34 +00:00
|
|
|
#include "../feature/babystep.h"
|
2019-02-27 10:38:56 +00:00
|
|
|
#endif
|
|
|
|
|
2017-09-06 11:28:32 +00:00
|
|
|
#include "printcounter.h"
|
|
|
|
|
2017-09-12 20:02:17 +00:00
|
|
|
#if ENABLED(FILAMENT_WIDTH_SENSOR)
|
|
|
|
#include "../feature/filwidth.h"
|
|
|
|
#endif
|
|
|
|
|
2020-06-18 20:23:03 +00:00
|
|
|
#if HAS_POWER_MONITOR
|
|
|
|
#include "../feature/power_monitor.h"
|
|
|
|
#endif
|
|
|
|
|
2018-04-25 11:44:26 +00:00
|
|
|
#if ENABLED(EMERGENCY_PARSER)
|
2020-03-13 21:29:29 +00:00
|
|
|
#include "../feature/e_parser.h"
|
2018-04-25 11:44:26 +00:00
|
|
|
#endif
|
|
|
|
|
2018-09-29 06:44:47 +00:00
|
|
|
#if ENABLED(PRINTER_EVENT_LEDS)
|
2018-10-11 02:25:43 +00:00
|
|
|
#include "../feature/leds/printer_event_leds.h"
|
2018-09-29 06:44:47 +00:00
|
|
|
#endif
|
|
|
|
|
2019-09-08 05:55:34 +00:00
|
|
|
#if ENABLED(JOYSTICK)
|
|
|
|
#include "../feature/joystick.h"
|
|
|
|
#endif
|
|
|
|
|
2019-01-12 06:41:48 +00:00
|
|
|
#if ENABLED(SINGLENOZZLE)
|
|
|
|
#include "tool_change.h"
|
|
|
|
#endif
|
|
|
|
|
2019-08-20 07:01:37 +00:00
|
|
|
#if USE_BEEPER
|
2019-05-22 02:31:05 +00:00
|
|
|
#include "../libs/buzzer.h"
|
|
|
|
#endif
|
|
|
|
|
2018-05-11 06:01:51 +00:00
|
|
|
#if HOTEND_USES_THERMISTOR
|
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2020-07-01 21:27:28 +00:00
|
|
|
static const temp_entry_t* heater_ttbl_map[2] = { HEATER_0_TEMPTABLE, HEATER_1_TEMPTABLE };
|
2018-05-28 11:18:11 +00:00
|
|
|
static constexpr uint8_t heater_ttbllen_map[2] = { HEATER_0_TEMPTABLE_LEN, HEATER_1_TEMPTABLE_LEN };
|
2018-05-11 06:01:51 +00:00
|
|
|
#else
|
2020-03-02 03:19:02 +00:00
|
|
|
#define NEXT_TEMPTABLE(N) ,HEATER_##N##_TEMPTABLE
|
|
|
|
#define NEXT_TEMPTABLE_LEN(N) ,HEATER_##N##_TEMPTABLE_LEN
|
2020-07-01 21:27:28 +00:00
|
|
|
static const temp_entry_t* heater_ttbl_map[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_TEMPTABLE REPEAT_S(1, HOTENDS, NEXT_TEMPTABLE));
|
2020-03-02 03:19:02 +00:00
|
|
|
static constexpr uint8_t heater_ttbllen_map[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_TEMPTABLE_LEN REPEAT_S(1, HOTENDS, NEXT_TEMPTABLE_LEN));
|
2018-05-11 06:01:51 +00:00
|
|
|
#endif
|
2013-06-06 22:49:25 +00:00
|
|
|
#endif
|
2012-12-09 22:00:06 +00:00
|
|
|
|
2016-04-29 01:18:13 +00:00
|
|
|
Temperature thermalManager;
|
2012-03-08 20:43:21 +00:00
|
|
|
|
2020-02-26 09:02:03 +00:00
|
|
|
const char str_t_thermal_runaway[] PROGMEM = STR_T_THERMAL_RUNAWAY,
|
|
|
|
str_t_heating_failed[] PROGMEM = STR_T_HEATING_FAILED;
|
|
|
|
|
2018-04-04 23:29:27 +00:00
|
|
|
/**
|
|
|
|
* Macros to include the heater id in temp errors. The compiler's dead-code
|
|
|
|
* elimination should (hopefully) optimize out the unused strings.
|
|
|
|
*/
|
2019-03-07 08:09:39 +00:00
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2019-10-10 00:46:10 +00:00
|
|
|
#define _BED_PSTR(h) (h) == H_BED ? GET_TEXT(MSG_BED) :
|
2019-03-07 08:09:39 +00:00
|
|
|
#else
|
2019-10-10 00:46:10 +00:00
|
|
|
#define _BED_PSTR(h)
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_HEATED_CHAMBER
|
2019-10-10 00:46:10 +00:00
|
|
|
#define _CHAMBER_PSTR(h) (h) == H_CHAMBER ? GET_TEXT(MSG_CHAMBER) :
|
2018-04-04 23:29:27 +00:00
|
|
|
#else
|
2019-10-10 00:46:10 +00:00
|
|
|
#define _CHAMBER_PSTR(h)
|
2018-04-04 23:29:27 +00:00
|
|
|
#endif
|
2019-10-10 00:46:10 +00:00
|
|
|
#define _E_PSTR(h,N) ((HOTENDS) > N && (h) == N) ? PSTR(LCD_STR_E##N) :
|
|
|
|
#define HEATER_PSTR(h) _BED_PSTR(h) _CHAMBER_PSTR(h) _E_PSTR(h,1) _E_PSTR(h,2) _E_PSTR(h,3) _E_PSTR(h,4) _E_PSTR(h,5) PSTR(LCD_STR_E0)
|
2018-04-04 23:29:27 +00:00
|
|
|
|
2016-05-26 18:58:38 +00:00
|
|
|
// public:
|
|
|
|
|
2019-02-04 06:12:41 +00:00
|
|
|
#if ENABLED(NO_FAN_SLOWING_IN_PID_TUNING)
|
|
|
|
bool Temperature::adaptive_fan_slowing = true;
|
|
|
|
#endif
|
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-09-10 07:20:49 +00:00
|
|
|
hotend_info_t Temperature::temp_hotend[HOTEND_TEMPS]; // = { 0 }
|
2020-06-25 01:14:58 +00:00
|
|
|
const uint16_t Temperature::heater_maxtemp[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP, HEATER_2_MAXTEMP, HEATER_3_MAXTEMP, HEATER_4_MAXTEMP, HEATER_5_MAXTEMP, HEATER_6_MAXTEMP, HEATER_7_MAXTEMP);
|
2019-09-10 07:20:49 +00:00
|
|
|
#endif
|
2017-05-28 16:11:17 +00:00
|
|
|
|
2018-02-06 06:22:30 +00:00
|
|
|
#if ENABLED(AUTO_POWER_E_FANS)
|
2019-01-12 06:41:48 +00:00
|
|
|
uint8_t Temperature::autofan_speed[HOTENDS]; // = { 0 }
|
2018-02-06 06:22:30 +00:00
|
|
|
#endif
|
|
|
|
|
2019-05-05 03:51:47 +00:00
|
|
|
#if ENABLED(AUTO_POWER_CHAMBER_FAN)
|
|
|
|
uint8_t Temperature::chamberfan_speed; // = 0
|
|
|
|
#endif
|
|
|
|
|
2020-04-27 09:41:18 +00:00
|
|
|
#if HAS_FAN
|
2019-01-12 06:41:48 +00:00
|
|
|
|
|
|
|
uint8_t Temperature::fan_speed[FAN_COUNT]; // = { 0 }
|
|
|
|
|
|
|
|
#if ENABLED(EXTRA_FAN_SPEED)
|
|
|
|
uint8_t Temperature::old_fan_speed[FAN_COUNT], Temperature::new_fan_speed[FAN_COUNT];
|
|
|
|
|
2019-01-20 00:47:29 +00:00
|
|
|
void Temperature::set_temp_fan_speed(const uint8_t fan, const uint16_t tmp_temp) {
|
2019-01-12 06:41:48 +00:00
|
|
|
switch (tmp_temp) {
|
|
|
|
case 1:
|
|
|
|
set_fan_speed(fan, old_fan_speed[fan]);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
old_fan_speed[fan] = fan_speed[fan];
|
|
|
|
set_fan_speed(fan, new_fan_speed[fan]);
|
|
|
|
break;
|
|
|
|
default:
|
2019-07-05 23:01:21 +00:00
|
|
|
new_fan_speed[fan] = _MIN(tmp_temp, 255U);
|
2019-01-12 06:41:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2019-05-07 19:14:12 +00:00
|
|
|
#if EITHER(PROBING_FANS_OFF, ADVANCED_PAUSE_FANS_PAUSE)
|
2019-01-12 06:41:48 +00:00
|
|
|
bool Temperature::fans_paused; // = false;
|
2019-05-07 19:14:12 +00:00
|
|
|
uint8_t Temperature::saved_fan_speed[FAN_COUNT]; // = { 0 }
|
2019-01-12 06:41:48 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(ADAPTIVE_FAN_SLOWING)
|
2020-08-20 01:11:20 +00:00
|
|
|
uint8_t Temperature::fan_speed_scaler[FAN_COUNT] = ARRAY_N(FAN_COUNT, 128, 128, 128, 128, 128, 128, 128, 128);
|
2019-01-12 06:41:48 +00:00
|
|
|
#endif
|
|
|
|
|
2019-06-28 18:58:40 +00:00
|
|
|
/**
|
|
|
|
* Set the print fan speed for a target extruder
|
|
|
|
*/
|
2019-01-12 06:41:48 +00:00
|
|
|
void Temperature::set_fan_speed(uint8_t target, uint16_t speed) {
|
|
|
|
|
|
|
|
NOMORE(speed, 255U);
|
|
|
|
|
2020-04-28 05:21:23 +00:00
|
|
|
#if ENABLED(SINGLENOZZLE_STANDBY_FAN)
|
2019-01-12 06:41:48 +00:00
|
|
|
if (target != active_extruder) {
|
|
|
|
if (target < EXTRUDERS) singlenozzle_fan_speed[target] = speed;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-08-26 10:23:56 +00:00
|
|
|
TERN_(SINGLENOZZLE, target = 0); // Always use fan index 0 with SINGLENOZZLE
|
|
|
|
|
2019-01-12 06:41:48 +00:00
|
|
|
if (target >= FAN_COUNT) return;
|
2019-01-18 00:03:58 +00:00
|
|
|
|
2019-01-12 06:41:48 +00:00
|
|
|
fan_speed[target] = speed;
|
2020-05-25 22:46:35 +00:00
|
|
|
|
2020-07-15 00:30:48 +00:00
|
|
|
TERN_(REPORT_FAN_CHANGE, report_fan_speed(target));
|
2019-01-12 06:41:48 +00:00
|
|
|
}
|
|
|
|
|
2020-07-15 00:30:48 +00:00
|
|
|
#if ENABLED(REPORT_FAN_CHANGE)
|
|
|
|
/**
|
|
|
|
* Report print fan speed for a target extruder
|
|
|
|
*/
|
|
|
|
void Temperature::report_fan_speed(const uint8_t target) {
|
|
|
|
if (target >= FAN_COUNT) return;
|
|
|
|
PORT_REDIRECT(SERIAL_BOTH);
|
|
|
|
SERIAL_ECHOLNPAIR("M106 P", target, " S", fan_speed[target]);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-05-04 20:50:44 +00:00
|
|
|
#if EITHER(PROBING_FANS_OFF, ADVANCED_PAUSE_FANS_PAUSE)
|
2019-01-12 06:41:48 +00:00
|
|
|
|
|
|
|
void Temperature::set_fans_paused(const bool p) {
|
|
|
|
if (p != fans_paused) {
|
|
|
|
fans_paused = p;
|
|
|
|
if (p)
|
2019-05-04 19:36:59 +00:00
|
|
|
FANS_LOOP(i) { saved_fan_speed[i] = fan_speed[i]; fan_speed[i] = 0; }
|
2019-01-12 06:41:48 +00:00
|
|
|
else
|
2019-05-04 19:36:59 +00:00
|
|
|
FANS_LOOP(i) fan_speed[i] = saved_fan_speed[i];
|
2019-01-12 06:41:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-04 20:50:44 +00:00
|
|
|
#endif
|
2019-01-12 06:41:48 +00:00
|
|
|
|
2020-04-27 09:41:18 +00:00
|
|
|
#endif // HAS_FAN
|
2019-01-12 06:41:48 +00:00
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
#if WATCH_HOTENDS
|
2020-01-30 09:24:43 +00:00
|
|
|
hotend_watch_t Temperature::watch_hotend[HOTENDS]; // = { { 0 } }
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif
|
|
|
|
#if HEATER_IDLE_HANDLER
|
2020-01-30 09:24:43 +00:00
|
|
|
hotend_idle_t Temperature::hotend_idle[HOTENDS]; // = { { 0 } }
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif
|
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2019-03-07 08:09:39 +00:00
|
|
|
bed_info_t Temperature::temp_bed; // = { 0 }
|
|
|
|
// Init min and max temp with extreme values to prevent false errors during startup
|
2018-04-23 22:13:01 +00:00
|
|
|
#ifdef BED_MINTEMP
|
2019-03-07 08:09:39 +00:00
|
|
|
int16_t Temperature::mintemp_raw_BED = HEATER_BED_RAW_LO_TEMP;
|
2018-04-23 22:13:01 +00:00
|
|
|
#endif
|
|
|
|
#ifdef BED_MAXTEMP
|
2019-03-07 08:09:39 +00:00
|
|
|
int16_t Temperature::maxtemp_raw_BED = HEATER_BED_RAW_HI_TEMP;
|
2018-04-23 22:13:01 +00:00
|
|
|
#endif
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(WATCH_BED, bed_watch_t Temperature::watch_bed); // = { 0 }
|
|
|
|
TERN(PIDTEMPBED,, millis_t Temperature::next_bed_check_ms);
|
|
|
|
TERN_(HEATER_IDLE_HANDLER, hotend_idle_t Temperature::bed_idle); // = { 0 }
|
2018-04-23 22:13:01 +00:00
|
|
|
#endif // HAS_HEATED_BED
|
|
|
|
|
|
|
|
#if HAS_TEMP_CHAMBER
|
2019-03-10 14:51:13 +00:00
|
|
|
chamber_info_t Temperature::temp_chamber; // = { 0 }
|
2019-03-07 08:09:39 +00:00
|
|
|
#if HAS_HEATED_CHAMBER
|
|
|
|
#ifdef CHAMBER_MINTEMP
|
|
|
|
int16_t Temperature::mintemp_raw_CHAMBER = HEATER_CHAMBER_RAW_LO_TEMP;
|
|
|
|
#endif
|
|
|
|
#ifdef CHAMBER_MAXTEMP
|
|
|
|
int16_t Temperature::maxtemp_raw_CHAMBER = HEATER_CHAMBER_RAW_HI_TEMP;
|
|
|
|
#endif
|
|
|
|
#if WATCH_CHAMBER
|
2020-01-30 09:24:43 +00:00
|
|
|
chamber_watch_t Temperature::watch_chamber{0};
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif
|
2019-05-07 00:55:01 +00:00
|
|
|
millis_t Temperature::next_chamber_check_ms;
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif // HAS_HEATED_CHAMBER
|
|
|
|
#endif // HAS_TEMP_CHAMBER
|
2016-05-26 18:58:38 +00:00
|
|
|
|
2020-01-17 23:16:45 +00:00
|
|
|
#if HAS_TEMP_PROBE
|
|
|
|
probe_info_t Temperature::temp_probe; // = { 0 }
|
|
|
|
#endif
|
|
|
|
|
2017-07-18 08:17:50 +00:00
|
|
|
// Initialized by settings.load()
|
2016-05-26 18:58:38 +00:00
|
|
|
#if ENABLED(PIDTEMP)
|
2019-03-07 08:09:39 +00:00
|
|
|
//hotend_pid_t Temperature::pid[HOTENDS];
|
2016-05-26 18:58:38 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-21 04:34:24 +00:00
|
|
|
#if ENABLED(PREVENT_COLD_EXTRUSION)
|
2016-07-06 15:28:09 +00:00
|
|
|
bool Temperature::allow_cold_extrude = false;
|
2017-06-10 23:29:17 +00:00
|
|
|
int16_t Temperature::extrude_min_temp = EXTRUDE_MINTEMP;
|
2016-05-26 18:58:38 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// private:
|
|
|
|
|
2018-03-22 00:04:45 +00:00
|
|
|
#if EARLY_WATCHDOG
|
|
|
|
bool Temperature::inited = false;
|
|
|
|
#endif
|
|
|
|
|
2016-05-26 18:58:38 +00:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2017-05-21 09:48:53 +00:00
|
|
|
uint16_t Temperature::redundant_temperature_raw = 0;
|
2016-05-26 18:58:38 +00:00
|
|
|
float Temperature::redundant_temperature = 0.0;
|
|
|
|
#endif
|
|
|
|
|
2020-01-26 23:39:45 +00:00
|
|
|
volatile bool Temperature::raw_temps_ready = false;
|
2016-05-26 18:58:38 +00:00
|
|
|
|
2019-02-27 10:38:56 +00:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2019-03-07 08:09:39 +00:00
|
|
|
int32_t Temperature::last_e_position, Temperature::lpq[LPQ_MAX_LEN];
|
|
|
|
lpq_ptr_t Temperature::lpq_ptr = 0;
|
2016-05-26 18:58:38 +00:00
|
|
|
#endif
|
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
#define TEMPDIR(N) ((HEATER_##N##_RAW_LO_TEMP) < (HEATER_##N##_RAW_HI_TEMP) ? 1 : -1)
|
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-09-10 07:20:49 +00:00
|
|
|
// Init mintemp and maxtemp with extreme values to prevent false errors during startup
|
|
|
|
constexpr temp_range_t sensor_heater_0 { HEATER_0_RAW_LO_TEMP, HEATER_0_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_1 { HEATER_1_RAW_LO_TEMP, HEATER_1_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_2 { HEATER_2_RAW_LO_TEMP, HEATER_2_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_3 { HEATER_3_RAW_LO_TEMP, HEATER_3_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_4 { HEATER_4_RAW_LO_TEMP, HEATER_4_RAW_HI_TEMP, 0, 16383 },
|
2020-01-25 08:13:39 +00:00
|
|
|
sensor_heater_5 { HEATER_5_RAW_LO_TEMP, HEATER_5_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_6 { HEATER_6_RAW_LO_TEMP, HEATER_6_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_7 { HEATER_7_RAW_LO_TEMP, HEATER_7_RAW_HI_TEMP, 0, 16383 };
|
2016-05-26 18:58:38 +00:00
|
|
|
|
2020-01-25 08:13:39 +00:00
|
|
|
temp_range_t Temperature::temp_range[HOTENDS] = ARRAY_BY_HOTENDS(sensor_heater_0, sensor_heater_1, sensor_heater_2, sensor_heater_3, sensor_heater_4, sensor_heater_5, sensor_heater_6, sensor_heater_7);
|
2019-09-10 07:20:49 +00:00
|
|
|
#endif
|
2016-05-26 18:58:38 +00:00
|
|
|
|
2016-07-09 02:28:37 +00:00
|
|
|
#ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
|
2017-05-03 22:12:14 +00:00
|
|
|
uint8_t Temperature::consecutive_low_temperature_error[HOTENDS] = { 0 };
|
2016-07-09 02:28:37 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef MILLISECONDS_PREHEAT_TIME
|
2017-05-03 22:12:14 +00:00
|
|
|
millis_t Temperature::preheat_end_time[HOTENDS] = { 0 };
|
2016-07-09 02:28:37 +00:00
|
|
|
#endif
|
|
|
|
|
2016-05-26 18:58:38 +00:00
|
|
|
#if HAS_AUTO_FAN
|
2016-08-14 02:52:24 +00:00
|
|
|
millis_t Temperature::next_auto_fan_check_ms = 0;
|
2016-05-26 18:58:38 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
2017-04-20 19:04:26 +00:00
|
|
|
uint8_t Temperature::soft_pwm_amount_fan[FAN_COUNT],
|
|
|
|
Temperature::soft_pwm_count_fan[FAN_COUNT];
|
2016-05-26 18:58:38 +00:00
|
|
|
#endif
|
|
|
|
|
2017-05-07 11:06:06 +00:00
|
|
|
#if ENABLED(PROBING_HEATERS_OFF)
|
|
|
|
bool Temperature::paused;
|
2017-05-26 18:01:02 +00:00
|
|
|
#endif
|
|
|
|
|
2019-02-27 10:38:56 +00:00
|
|
|
// public:
|
|
|
|
|
2018-11-19 02:39:49 +00:00
|
|
|
#if HAS_ADC_BUTTONS
|
2019-11-06 23:49:17 +00:00
|
|
|
uint32_t Temperature::current_ADCKey_raw = HAL_ADC_RANGE;
|
2020-06-26 23:53:39 +00:00
|
|
|
uint16_t Temperature::ADCKey_count = 0;
|
2017-06-10 05:12:18 +00:00
|
|
|
#endif
|
|
|
|
|
2018-05-12 07:13:40 +00:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2020-08-20 05:08:06 +00:00
|
|
|
int16_t Temperature::lpq_len; // Initialized in settings.cpp
|
2018-05-12 07:13:40 +00:00
|
|
|
#endif
|
|
|
|
|
2016-04-20 01:09:29 +00:00
|
|
|
#if HAS_PID_HEATING
|
2016-10-09 21:13:58 +00:00
|
|
|
|
2018-11-29 22:58:58 +00:00
|
|
|
inline void say_default_() { SERIAL_ECHOPGM("#define DEFAULT_"); }
|
2018-10-10 14:45:20 +00:00
|
|
|
|
2017-11-10 06:48:00 +00:00
|
|
|
/**
|
|
|
|
* PID Autotuning (M303)
|
|
|
|
*
|
|
|
|
* Alternately heat and cool the nozzle, observing its behavior to
|
|
|
|
* determine the best PID values to achieve a stable temperature.
|
2019-02-10 09:54:45 +00:00
|
|
|
* Needs sufficient heater power to make some overshoot at target
|
|
|
|
* temperature to succeed.
|
2017-11-10 06:48:00 +00:00
|
|
|
*/
|
2020-09-13 23:06:14 +00:00
|
|
|
void Temperature::PID_autotune(const float &target, const heater_id_t heater_id, const int8_t ncycles, const bool set_result/*=false*/) {
|
2019-09-09 07:56:23 +00:00
|
|
|
float current_temp = 0.0;
|
2016-04-19 02:02:11 +00:00
|
|
|
int cycles = 0;
|
|
|
|
bool heating = true;
|
2012-03-08 20:43:21 +00:00
|
|
|
|
2017-10-29 09:30:50 +00:00
|
|
|
millis_t next_temp_ms = millis(), t1 = next_temp_ms, t2 = next_temp_ms;
|
2016-04-19 02:02:11 +00:00
|
|
|
long t_high = 0, t_low = 0;
|
2012-03-08 20:43:21 +00:00
|
|
|
|
2016-04-19 02:02:11 +00:00
|
|
|
long bias, d;
|
2018-10-10 14:45:20 +00:00
|
|
|
PID_t tune_pid = { 0, 0, 0 };
|
2019-09-05 03:34:00 +00:00
|
|
|
float maxT = 0, minT = 10000;
|
2017-11-03 08:24:19 +00:00
|
|
|
|
2020-09-13 23:06:14 +00:00
|
|
|
const bool isbed = (heater_id == H_BED);
|
2019-06-26 05:40:29 +00:00
|
|
|
|
2018-07-15 21:07:31 +00:00
|
|
|
#if HAS_PID_FOR_BOTH
|
2019-06-22 21:52:56 +00:00
|
|
|
#define GHV(B,H) (isbed ? (B) : (H))
|
2020-09-13 23:06:14 +00:00
|
|
|
#define SHV(B,H) do{ if (isbed) temp_bed.soft_pwm_amount = B; else temp_hotend[heater_id].soft_pwm_amount = H; }while(0)
|
2019-06-22 21:52:56 +00:00
|
|
|
#define ONHEATINGSTART() (isbed ? printerEventLEDs.onBedHeatingStart() : printerEventLEDs.onHotendHeatingStart())
|
|
|
|
#define ONHEATING(S,C,T) (isbed ? printerEventLEDs.onBedHeating(S,C,T) : printerEventLEDs.onHotendHeating(S,C,T))
|
2018-07-15 21:07:31 +00:00
|
|
|
#elif ENABLED(PIDTEMPBED)
|
|
|
|
#define GHV(B,H) B
|
2019-03-07 08:09:39 +00:00
|
|
|
#define SHV(B,H) (temp_bed.soft_pwm_amount = B)
|
2018-10-11 02:25:43 +00:00
|
|
|
#define ONHEATINGSTART() printerEventLEDs.onBedHeatingStart()
|
|
|
|
#define ONHEATING(S,C,T) printerEventLEDs.onBedHeating(S,C,T)
|
2018-01-04 03:30:45 +00:00
|
|
|
#else
|
2018-07-15 21:07:31 +00:00
|
|
|
#define GHV(B,H) H
|
2020-09-13 23:06:14 +00:00
|
|
|
#define SHV(B,H) (temp_hotend[heater_id].soft_pwm_amount = H)
|
2018-10-11 02:25:43 +00:00
|
|
|
#define ONHEATINGSTART() printerEventLEDs.onHotendHeatingStart()
|
|
|
|
#define ONHEATING(S,C,T) printerEventLEDs.onHotendHeating(S,C,T)
|
2018-01-04 03:30:45 +00:00
|
|
|
#endif
|
2020-05-18 18:51:32 +00:00
|
|
|
#define WATCH_PID BOTH(WATCH_BED, PIDTEMPBED) || BOTH(WATCH_HOTENDS, PIDTEMP)
|
2018-01-04 03:30:45 +00:00
|
|
|
|
2020-05-18 18:51:32 +00:00
|
|
|
#if WATCH_PID
|
|
|
|
#if ALL(THERMAL_PROTECTION_HOTENDS, PIDTEMP, THERMAL_PROTECTION_BED, PIDTEMPBED)
|
2019-06-22 21:52:56 +00:00
|
|
|
#define GTV(B,H) (isbed ? (B) : (H))
|
2020-05-18 18:51:32 +00:00
|
|
|
#elif BOTH(THERMAL_PROTECTION_HOTENDS, PIDTEMP)
|
2018-07-15 21:07:31 +00:00
|
|
|
#define GTV(B,H) (H)
|
2020-05-18 18:51:32 +00:00
|
|
|
#else
|
|
|
|
#define GTV(B,H) (B)
|
2018-07-15 21:07:31 +00:00
|
|
|
#endif
|
|
|
|
const uint16_t watch_temp_period = GTV(WATCH_BED_TEMP_PERIOD, WATCH_TEMP_PERIOD);
|
|
|
|
const uint8_t watch_temp_increase = GTV(WATCH_BED_TEMP_INCREASE, WATCH_TEMP_INCREASE);
|
|
|
|
const float watch_temp_target = target - float(watch_temp_increase + GTV(TEMP_BED_HYSTERESIS, TEMP_HYSTERESIS) + 1);
|
2020-04-04 00:49:45 +00:00
|
|
|
millis_t temp_change_ms = next_temp_ms + SEC_TO_MS(watch_temp_period);
|
2017-11-03 08:24:19 +00:00
|
|
|
float next_watch_temp = 0.0;
|
|
|
|
bool heated = false;
|
|
|
|
#endif
|
2012-09-13 02:01:31 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HAS_AUTO_FAN, next_auto_fan_check_ms = next_temp_ms + 2500UL);
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2020-09-13 23:06:14 +00:00
|
|
|
if (target > GHV(BED_MAX_TARGET, temp_range[heater_id].maxtemp - HOTEND_OVERSHOOT)) {
|
2020-02-26 09:02:03 +00:00
|
|
|
SERIAL_ECHOLNPGM(STR_PID_TEMP_TOO_HIGH);
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(EXTENSIBLE_UI, ExtUI::onPidTuning(ExtUI::result_t::PID_TEMP_TOO_HIGH));
|
2018-12-20 21:55:30 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-02-26 09:02:03 +00:00
|
|
|
SERIAL_ECHOLNPGM(STR_PID_AUTOTUNE_START);
|
2012-09-13 02:01:31 +00:00
|
|
|
|
2018-10-19 02:20:56 +00:00
|
|
|
disable_all_heaters();
|
2020-08-24 14:54:25 +00:00
|
|
|
TERN_(AUTO_POWER_CONTROL, powerManager.power_on());
|
2012-09-13 02:01:31 +00:00
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
SHV(bias = d = (MAX_BED_POWER) >> 1, bias = d = (PID_MAX) >> 1);
|
2012-09-13 02:01:31 +00:00
|
|
|
|
2018-10-11 02:25:43 +00:00
|
|
|
#if ENABLED(PRINTER_EVENT_LEDS)
|
2020-09-13 23:06:14 +00:00
|
|
|
const float start_temp = GHV(temp_bed.celsius, temp_hotend[heater_id].celsius);
|
2018-11-01 22:44:41 +00:00
|
|
|
LEDColor color = ONHEATINGSTART();
|
2018-10-11 02:25:43 +00:00
|
|
|
#endif
|
Add an emergency-command parser to MarlinSerial (supporting M108)
Add an emergency-command parser to MarlinSerial's RX interrupt.
The parser tries to find and execute M108,M112,M410 before the commands disappear in the RX-buffer.
To avoid false positives for M117, comments and commands followed by filenames (M23, M28, M30, M32, M33) are filtered.
This enables Marlin to receive and react on the Emergency command at all times - regardless of whether the buffers are full or not. It remains to convince hosts to send the commands. To inform the hosts about the new feature a new entry in the M115-report was made. "`EMERGENCY_CODES:M112,M108,M410;`".
The parser is fast. It only ever needs two switch decisions and one assignment of the new state for every character.
One problem remains. If the host has sent an incomplete line before sending an emergency command the emergency command could be omitted when the parser is in `state_IGNORE`.
In that case the host should send "\ncommand\n"
Also introduces M108 to break the waiting for the heaters in M109, M190 and M303.
Rename `cancel_heatup` to `wait_for_heatup` to better see the purpose.
2016-07-04 21:23:22 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(NO_FAN_SLOWING_IN_PID_TUNING, adaptive_fan_slowing = false);
|
2019-02-04 06:12:41 +00:00
|
|
|
|
2016-04-19 02:02:11 +00:00
|
|
|
// PID Tuning loop
|
2020-09-12 03:51:19 +00:00
|
|
|
wait_for_heatup = true; // Can be interrupted with M108
|
Add an emergency-command parser to MarlinSerial (supporting M108)
Add an emergency-command parser to MarlinSerial's RX interrupt.
The parser tries to find and execute M108,M112,M410 before the commands disappear in the RX-buffer.
To avoid false positives for M117, comments and commands followed by filenames (M23, M28, M30, M32, M33) are filtered.
This enables Marlin to receive and react on the Emergency command at all times - regardless of whether the buffers are full or not. It remains to convince hosts to send the commands. To inform the hosts about the new feature a new entry in the M115-report was made. "`EMERGENCY_CODES:M112,M108,M410;`".
The parser is fast. It only ever needs two switch decisions and one assignment of the new state for every character.
One problem remains. If the host has sent an incomplete line before sending an emergency command the emergency command could be omitted when the parser is in `state_IGNORE`.
In that case the host should send "\ncommand\n"
Also introduces M108 to break the waiting for the heaters in M109, M190 and M303.
Rename `cancel_heatup` to `wait_for_heatup` to better see the purpose.
2016-07-04 21:23:22 +00:00
|
|
|
while (wait_for_heatup) {
|
2012-03-08 20:43:21 +00:00
|
|
|
|
2017-10-29 09:30:50 +00:00
|
|
|
const millis_t ms = millis();
|
2012-12-09 22:00:06 +00:00
|
|
|
|
2020-01-26 23:39:45 +00:00
|
|
|
if (raw_temps_ready) { // temp sample ready
|
2016-04-19 02:02:11 +00:00
|
|
|
updateTemperaturesFromRawValues();
|
2012-09-13 02:01:31 +00:00
|
|
|
|
2018-01-04 03:30:45 +00:00
|
|
|
// Get the current temperature and constrain it
|
2020-09-13 23:06:14 +00:00
|
|
|
current_temp = GHV(temp_bed.celsius, temp_hotend[heater_id].celsius);
|
2019-09-09 07:56:23 +00:00
|
|
|
NOLESS(maxT, current_temp);
|
|
|
|
NOMORE(minT, current_temp);
|
2014-12-24 04:35:54 +00:00
|
|
|
|
2018-10-11 02:25:43 +00:00
|
|
|
#if ENABLED(PRINTER_EVENT_LEDS)
|
2019-09-09 07:56:23 +00:00
|
|
|
ONHEATING(start_temp, current_temp, target);
|
2018-10-11 02:25:43 +00:00
|
|
|
#endif
|
|
|
|
|
2016-04-19 02:02:11 +00:00
|
|
|
#if HAS_AUTO_FAN
|
|
|
|
if (ELAPSED(ms, next_auto_fan_check_ms)) {
|
|
|
|
checkExtruderAutoFans();
|
|
|
|
next_auto_fan_check_ms = ms + 2500UL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-09-09 07:56:23 +00:00
|
|
|
if (heating && current_temp > target) {
|
2016-04-19 02:02:11 +00:00
|
|
|
if (ELAPSED(ms, t2 + 5000UL)) {
|
|
|
|
heating = false;
|
2019-03-07 08:09:39 +00:00
|
|
|
SHV((bias - d) >> 1, (bias - d) >> 1);
|
2016-04-19 02:02:11 +00:00
|
|
|
t1 = ms;
|
|
|
|
t_high = t1 - t2;
|
2019-09-05 03:34:00 +00:00
|
|
|
maxT = target;
|
2016-04-19 02:02:11 +00:00
|
|
|
}
|
2012-03-08 20:43:21 +00:00
|
|
|
}
|
2015-05-13 09:02:19 +00:00
|
|
|
|
2019-09-09 07:56:23 +00:00
|
|
|
if (!heating && current_temp < target) {
|
2016-04-19 02:02:11 +00:00
|
|
|
if (ELAPSED(ms, t1 + 5000UL)) {
|
|
|
|
heating = true;
|
|
|
|
t2 = ms;
|
|
|
|
t_low = t2 - t1;
|
|
|
|
if (cycles > 0) {
|
2018-07-15 21:07:31 +00:00
|
|
|
const long max_pow = GHV(MAX_BED_POWER, PID_MAX);
|
2016-04-19 02:02:11 +00:00
|
|
|
bias += (d * (t_high - t_low)) / (t_low + t_high);
|
2019-07-10 08:33:28 +00:00
|
|
|
LIMIT(bias, 20, max_pow - 20);
|
2017-11-03 08:24:19 +00:00
|
|
|
d = (bias > max_pow >> 1) ? max_pow - 1 - bias : bias;
|
2016-04-19 02:02:11 +00:00
|
|
|
|
2020-02-26 09:02:03 +00:00
|
|
|
SERIAL_ECHOPAIR(STR_BIAS, bias, STR_D_COLON, d, STR_T_MIN, minT, STR_T_MAX, maxT);
|
2016-04-19 02:02:11 +00:00
|
|
|
if (cycles > 2) {
|
2019-09-05 03:34:00 +00:00
|
|
|
const float Ku = (4.0f * d) / (float(M_PI) * (maxT - minT) * 0.5f),
|
2019-06-22 21:52:56 +00:00
|
|
|
Tu = float(t_low + t_high) * 0.001f,
|
|
|
|
pf = isbed ? 0.2f : 0.6f,
|
|
|
|
df = isbed ? 1.0f / 3.0f : 1.0f / 8.0f;
|
2019-07-28 20:50:25 +00:00
|
|
|
|
2020-02-26 09:02:03 +00:00
|
|
|
SERIAL_ECHOPAIR(STR_KU, Ku, STR_TU, Tu);
|
2019-07-28 20:50:25 +00:00
|
|
|
if (isbed) { // Do not remove this otherwise PID autotune won't work right for the bed!
|
|
|
|
tune_pid.Kp = Ku * 0.2f;
|
|
|
|
tune_pid.Ki = 2 * tune_pid.Kp / Tu;
|
|
|
|
tune_pid.Kd = tune_pid.Kp * Tu / 3;
|
|
|
|
SERIAL_ECHOLNPGM("\n" " No overshoot"); // Works far better for the bed. Classic and some have bad ringing.
|
2020-02-26 09:02:03 +00:00
|
|
|
SERIAL_ECHOLNPAIR(STR_KP, tune_pid.Kp, STR_KI, tune_pid.Ki, STR_KD, tune_pid.Kd);
|
2019-07-28 20:50:25 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
tune_pid.Kp = Ku * pf;
|
|
|
|
tune_pid.Kd = tune_pid.Kp * Tu * df;
|
|
|
|
tune_pid.Ki = 2 * tune_pid.Kp / Tu;
|
2020-02-26 09:02:03 +00:00
|
|
|
SERIAL_ECHOLNPGM("\n" STR_CLASSIC_PID);
|
|
|
|
SERIAL_ECHOLNPAIR(STR_KP, tune_pid.Kp, STR_KI, tune_pid.Ki, STR_KD, tune_pid.Kd);
|
2019-07-28 20:50:25 +00:00
|
|
|
}
|
|
|
|
|
2016-04-19 02:02:11 +00:00
|
|
|
/**
|
2019-06-22 21:52:56 +00:00
|
|
|
tune_pid.Kp = 0.33 * Ku;
|
|
|
|
tune_pid.Ki = tune_pid.Kp / Tu;
|
|
|
|
tune_pid.Kd = tune_pid.Kp * Tu / 3;
|
2018-11-29 22:58:58 +00:00
|
|
|
SERIAL_ECHOLNPGM(" Some overshoot");
|
2019-03-05 12:46:19 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" Kp: ", tune_pid.Kp, " Ki: ", tune_pid.Ki, " Kd: ", tune_pid.Kd, " No overshoot");
|
2019-06-22 21:52:56 +00:00
|
|
|
tune_pid.Kp = 0.2 * Ku;
|
|
|
|
tune_pid.Ki = 2 * tune_pid.Kp / Tu;
|
|
|
|
tune_pid.Kd = tune_pid.Kp * Tu / 3;
|
2019-03-05 12:46:19 +00:00
|
|
|
SERIAL_ECHOPAIR(" Kp: ", tune_pid.Kp, " Ki: ", tune_pid.Ki, " Kd: ", tune_pid.Kd);
|
2016-04-19 02:02:11 +00:00
|
|
|
*/
|
|
|
|
}
|
2012-03-08 20:43:21 +00:00
|
|
|
}
|
2019-03-07 08:09:39 +00:00
|
|
|
SHV((bias + d) >> 1, (bias + d) >> 1);
|
2016-04-19 02:02:11 +00:00
|
|
|
cycles++;
|
2019-09-05 03:34:00 +00:00
|
|
|
minT = target;
|
2012-03-08 20:43:21 +00:00
|
|
|
}
|
|
|
|
}
|
2015-10-03 06:08:58 +00:00
|
|
|
}
|
2018-01-04 03:30:45 +00:00
|
|
|
|
|
|
|
// Did the temperature overshoot very far?
|
2018-03-20 21:48:36 +00:00
|
|
|
#ifndef MAX_OVERSHOOT_PID_AUTOTUNE
|
2019-09-25 14:43:00 +00:00
|
|
|
#define MAX_OVERSHOOT_PID_AUTOTUNE 30
|
2018-03-20 21:48:36 +00:00
|
|
|
#endif
|
2019-09-09 07:56:23 +00:00
|
|
|
if (current_temp > target + MAX_OVERSHOOT_PID_AUTOTUNE) {
|
2020-02-26 09:02:03 +00:00
|
|
|
SERIAL_ECHOLNPGM(STR_PID_TEMP_TOO_HIGH);
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(EXTENSIBLE_UI, ExtUI::onPidTuning(ExtUI::result_t::PID_TEMP_TOO_HIGH));
|
2017-10-29 09:30:50 +00:00
|
|
|
break;
|
2016-04-19 02:02:11 +00:00
|
|
|
}
|
2018-01-04 03:30:45 +00:00
|
|
|
|
|
|
|
// Report heater states every 2 seconds
|
2017-10-29 09:30:50 +00:00
|
|
|
if (ELAPSED(ms, next_temp_ms)) {
|
2018-03-07 07:53:50 +00:00
|
|
|
#if HAS_TEMP_SENSOR
|
2020-09-13 23:06:14 +00:00
|
|
|
print_heater_states(isbed ? active_extruder : heater_id);
|
2017-06-09 15:51:23 +00:00
|
|
|
SERIAL_EOL();
|
2016-04-19 02:02:11 +00:00
|
|
|
#endif
|
2017-10-29 09:30:50 +00:00
|
|
|
next_temp_ms = ms + 2000UL;
|
2017-11-03 08:24:19 +00:00
|
|
|
|
2018-01-04 03:30:45 +00:00
|
|
|
// Make sure heating is actually working
|
2020-05-18 18:51:32 +00:00
|
|
|
#if WATCH_PID
|
2020-04-01 23:53:58 +00:00
|
|
|
if (BOTH(WATCH_BED, WATCH_HOTENDS) || isbed == DISABLED(WATCH_HOTENDS)) {
|
|
|
|
if (!heated) { // If not yet reached target...
|
|
|
|
if (current_temp > next_watch_temp) { // Over the watch temp?
|
|
|
|
next_watch_temp = current_temp + watch_temp_increase; // - set the next temp to watch for
|
2020-04-04 00:49:45 +00:00
|
|
|
temp_change_ms = ms + SEC_TO_MS(watch_temp_period); // - move the expiration timer up
|
2020-04-01 23:53:58 +00:00
|
|
|
if (current_temp > watch_temp_target) heated = true; // - Flag if target temperature reached
|
2018-03-20 21:48:36 +00:00
|
|
|
}
|
2020-04-01 23:53:58 +00:00
|
|
|
else if (ELAPSED(ms, temp_change_ms)) // Watch timer expired
|
2020-09-13 23:06:14 +00:00
|
|
|
_temp_error(heater_id, str_t_heating_failed, GET_TEXT(MSG_HEATING_FAILED_LCD));
|
2018-01-04 03:30:45 +00:00
|
|
|
}
|
2019-09-09 07:56:23 +00:00
|
|
|
else if (current_temp < target - (MAX_OVERSHOOT_PID_AUTOTUNE)) // Heated, then temperature fell too far?
|
2020-09-13 23:06:14 +00:00
|
|
|
_temp_error(heater_id, str_t_thermal_runaway, GET_TEXT(MSG_THERMAL_RUNAWAY));
|
2017-11-03 08:24:19 +00:00
|
|
|
}
|
|
|
|
#endif
|
2016-04-19 02:02:11 +00:00
|
|
|
} // every 2 seconds
|
2018-01-04 03:30:45 +00:00
|
|
|
|
2018-03-20 21:48:36 +00:00
|
|
|
// Timeout after MAX_CYCLE_TIME_PID_AUTOTUNE minutes since the last undershoot/overshoot cycle
|
|
|
|
#ifndef MAX_CYCLE_TIME_PID_AUTOTUNE
|
|
|
|
#define MAX_CYCLE_TIME_PID_AUTOTUNE 20L
|
|
|
|
#endif
|
2020-06-18 21:05:12 +00:00
|
|
|
if ((ms - _MIN(t1, t2)) > (MAX_CYCLE_TIME_PID_AUTOTUNE * 60L * 1000L)) {
|
2020-06-16 06:45:27 +00:00
|
|
|
TERN_(DWIN_CREALITY_LCD, Popup_Window_Temperature(0));
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(EXTENSIBLE_UI, ExtUI::onPidTuning(ExtUI::result_t::PID_TUNING_TIMEOUT));
|
2020-02-26 09:02:03 +00:00
|
|
|
SERIAL_ECHOLNPGM(STR_PID_TIMEOUT);
|
2017-10-29 09:30:50 +00:00
|
|
|
break;
|
2016-04-19 02:02:11 +00:00
|
|
|
}
|
2018-01-04 03:30:45 +00:00
|
|
|
|
2019-02-10 09:54:45 +00:00
|
|
|
if (cycles > ncycles && cycles > 2) {
|
2020-02-26 09:02:03 +00:00
|
|
|
SERIAL_ECHOLNPGM(STR_PID_AUTOTUNE_FINISHED);
|
2016-04-20 01:09:29 +00:00
|
|
|
|
|
|
|
#if HAS_PID_FOR_BOTH
|
2019-11-02 12:09:57 +00:00
|
|
|
const char * const estring = GHV(PSTR("bed"), NUL_STR);
|
2018-11-29 22:58:58 +00:00
|
|
|
say_default_(); serialprintPGM(estring); SERIAL_ECHOLNPAIR("Kp ", tune_pid.Kp);
|
|
|
|
say_default_(); serialprintPGM(estring); SERIAL_ECHOLNPAIR("Ki ", tune_pid.Ki);
|
|
|
|
say_default_(); serialprintPGM(estring); SERIAL_ECHOLNPAIR("Kd ", tune_pid.Kd);
|
2016-04-20 01:09:29 +00:00
|
|
|
#elif ENABLED(PIDTEMP)
|
2018-11-29 22:58:58 +00:00
|
|
|
say_default_(); SERIAL_ECHOLNPAIR("Kp ", tune_pid.Kp);
|
|
|
|
say_default_(); SERIAL_ECHOLNPAIR("Ki ", tune_pid.Ki);
|
|
|
|
say_default_(); SERIAL_ECHOLNPAIR("Kd ", tune_pid.Kd);
|
2016-04-20 01:09:29 +00:00
|
|
|
#else
|
2018-11-29 22:58:58 +00:00
|
|
|
say_default_(); SERIAL_ECHOLNPAIR("bedKp ", tune_pid.Kp);
|
|
|
|
say_default_(); SERIAL_ECHOLNPAIR("bedKi ", tune_pid.Ki);
|
|
|
|
say_default_(); SERIAL_ECHOLNPAIR("bedKd ", tune_pid.Kd);
|
2016-04-20 01:09:29 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-11 01:49:25 +00:00
|
|
|
#define _SET_BED_PID() do { \
|
2019-03-07 08:09:39 +00:00
|
|
|
temp_bed.pid.Kp = tune_pid.Kp; \
|
|
|
|
temp_bed.pid.Ki = scalePID_i(tune_pid.Ki); \
|
|
|
|
temp_bed.pid.Kd = scalePID_d(tune_pid.Kd); \
|
2017-11-10 06:48:00 +00:00
|
|
|
}while(0)
|
2016-04-20 01:09:29 +00:00
|
|
|
|
2016-08-11 01:49:25 +00:00
|
|
|
#define _SET_EXTRUDER_PID() do { \
|
2020-09-13 23:06:14 +00:00
|
|
|
PID_PARAM(Kp, heater_id) = tune_pid.Kp; \
|
|
|
|
PID_PARAM(Ki, heater_id) = scalePID_i(tune_pid.Ki); \
|
|
|
|
PID_PARAM(Kd, heater_id) = scalePID_d(tune_pid.Kd); \
|
2017-06-15 20:14:08 +00:00
|
|
|
updatePID(); }while(0)
|
2016-04-19 02:02:11 +00:00
|
|
|
|
|
|
|
// Use the result? (As with "M303 U1")
|
|
|
|
if (set_result) {
|
2016-04-20 01:09:29 +00:00
|
|
|
#if HAS_PID_FOR_BOTH
|
2019-06-22 21:52:56 +00:00
|
|
|
if (isbed) _SET_BED_PID(); else _SET_EXTRUDER_PID();
|
2016-04-20 01:09:29 +00:00
|
|
|
#elif ENABLED(PIDTEMP)
|
|
|
|
_SET_EXTRUDER_PID();
|
|
|
|
#else
|
|
|
|
_SET_BED_PID();
|
|
|
|
#endif
|
2016-03-20 13:56:11 +00:00
|
|
|
}
|
2019-02-04 06:12:41 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(PRINTER_EVENT_LEDS, printerEventLEDs.onPidTuningDone(color));
|
|
|
|
|
|
|
|
TERN_(EXTENSIBLE_UI, ExtUI::onPidTuning(ExtUI::result_t::PID_DONE));
|
2018-11-01 22:44:41 +00:00
|
|
|
|
2019-02-04 06:12:41 +00:00
|
|
|
goto EXIT_M303;
|
2016-03-20 13:56:11 +00:00
|
|
|
}
|
2020-06-16 06:45:27 +00:00
|
|
|
TERN(DWIN_CREALITY_LCD, DWIN_Update(), ui.update());
|
2012-04-15 17:17:33 +00:00
|
|
|
}
|
2020-09-12 03:51:19 +00:00
|
|
|
wait_for_heatup = false;
|
2019-02-04 06:12:41 +00:00
|
|
|
|
2017-10-29 09:30:50 +00:00
|
|
|
disable_all_heaters();
|
2019-02-04 06:12:41 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(PRINTER_EVENT_LEDS, printerEventLEDs.onPidTuningDone(color));
|
|
|
|
|
|
|
|
TERN_(EXTENSIBLE_UI, ExtUI::onPidTuning(ExtUI::result_t::PID_DONE));
|
2019-02-04 06:12:41 +00:00
|
|
|
|
|
|
|
EXIT_M303:
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(NO_FAN_SLOWING_IN_PID_TUNING, adaptive_fan_slowing = true);
|
2019-02-04 06:12:41 +00:00
|
|
|
return;
|
2012-03-08 20:43:21 +00:00
|
|
|
}
|
|
|
|
|
2016-04-29 01:18:13 +00:00
|
|
|
#endif // HAS_PID_HEATING
|
|
|
|
|
2016-05-26 18:58:38 +00:00
|
|
|
/**
|
|
|
|
* Class and Instance Methods
|
|
|
|
*/
|
2016-04-29 01:18:13 +00:00
|
|
|
|
2020-09-13 23:06:14 +00:00
|
|
|
int16_t Temperature::getHeaterPower(const heater_id_t heater_id) {
|
2019-07-02 13:39:55 +00:00
|
|
|
switch (heater_id) {
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2019-07-02 13:39:55 +00:00
|
|
|
case H_BED: return temp_bed.soft_pwm_amount;
|
|
|
|
#endif
|
|
|
|
#if HAS_HEATED_CHAMBER
|
|
|
|
case H_CHAMBER: return temp_chamber.soft_pwm_amount;
|
2018-04-23 22:13:01 +00:00
|
|
|
#endif
|
2019-09-10 07:20:49 +00:00
|
|
|
default:
|
2020-04-22 21:35:03 +00:00
|
|
|
return TERN0(HAS_HOTEND, temp_hotend[heater_id].soft_pwm_amount);
|
2019-07-02 13:39:55 +00:00
|
|
|
}
|
2011-12-12 18:34:37 +00:00
|
|
|
}
|
|
|
|
|
2019-10-10 00:46:10 +00:00
|
|
|
#define _EFANOVERLAP(A,B) _FANOVERLAP(E##A,B)
|
|
|
|
|
2015-02-26 09:14:59 +00:00
|
|
|
#if HAS_AUTO_FAN
|
2016-10-09 21:13:58 +00:00
|
|
|
|
2019-05-05 03:51:47 +00:00
|
|
|
#define CHAMBER_FAN_INDEX HOTENDS
|
2019-03-13 11:51:15 +00:00
|
|
|
|
2016-04-29 01:18:13 +00:00
|
|
|
void Temperature::checkExtruderAutoFans() {
|
2019-11-09 23:59:04 +00:00
|
|
|
#define _EFAN(B,A) _EFANOVERLAP(A,B) ? B :
|
2017-06-06 11:33:06 +00:00
|
|
|
static const uint8_t fanBit[] PROGMEM = {
|
2019-05-05 03:51:47 +00:00
|
|
|
0
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_MULTI_HOTEND
|
2020-02-02 03:00:53 +00:00
|
|
|
#define _NEXT_FAN(N) , REPEAT2(N,_EFAN,N) N
|
|
|
|
RREPEAT_S(1, HOTENDS, _NEXT_FAN)
|
2019-05-05 03:51:47 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_AUTO_CHAMBER_FAN
|
2019-10-10 00:46:10 +00:00
|
|
|
#define _CFAN(B) _FANOVERLAP(CHAMBER,B) ? B :
|
2019-11-09 23:59:04 +00:00
|
|
|
, REPEAT(HOTENDS,_CFAN) (HOTENDS)
|
2019-03-05 06:41:31 +00:00
|
|
|
#endif
|
2016-04-29 01:18:13 +00:00
|
|
|
};
|
2016-10-29 18:42:43 +00:00
|
|
|
|
2019-11-09 23:59:04 +00:00
|
|
|
uint8_t fanState = 0;
|
2017-06-06 11:33:06 +00:00
|
|
|
HOTEND_LOOP()
|
2019-09-09 07:56:23 +00:00
|
|
|
if (temp_hotend[e].celsius >= EXTRUDER_AUTO_FAN_TEMPERATURE)
|
2017-06-06 11:33:06 +00:00
|
|
|
SBI(fanState, pgm_read_byte(&fanBit[e]));
|
2018-04-24 12:55:58 +00:00
|
|
|
|
2019-05-05 03:51:47 +00:00
|
|
|
#if HAS_AUTO_CHAMBER_FAN
|
2019-09-09 07:56:23 +00:00
|
|
|
if (temp_chamber.celsius >= CHAMBER_AUTO_FAN_TEMPERATURE)
|
2019-05-05 03:51:47 +00:00
|
|
|
SBI(fanState, pgm_read_byte(&fanBit[CHAMBER_FAN_INDEX]));
|
2018-04-24 12:55:58 +00:00
|
|
|
#endif
|
2016-10-29 18:42:43 +00:00
|
|
|
|
2019-07-02 09:04:49 +00:00
|
|
|
#define _UPDATE_AUTO_FAN(P,D,A) do{ \
|
|
|
|
if (PWM_PIN(P##_AUTO_FAN_PIN) && A < 255) \
|
|
|
|
analogWrite(pin_t(P##_AUTO_FAN_PIN), D ? A : 0); \
|
|
|
|
else \
|
|
|
|
WRITE(P##_AUTO_FAN_PIN, D); \
|
2019-03-05 06:41:31 +00:00
|
|
|
}while(0)
|
|
|
|
|
2016-05-16 01:54:37 +00:00
|
|
|
uint8_t fanDone = 0;
|
2020-03-14 04:18:16 +00:00
|
|
|
LOOP_L_N(f, COUNT(fanBit)) {
|
2019-05-05 03:51:47 +00:00
|
|
|
const uint8_t realFan = pgm_read_byte(&fanBit[f]);
|
|
|
|
if (TEST(fanDone, realFan)) continue;
|
|
|
|
const bool fan_on = TEST(fanState, realFan);
|
|
|
|
switch (f) {
|
2019-08-16 23:42:24 +00:00
|
|
|
#if ENABLED(AUTO_POWER_CHAMBER_FAN)
|
2019-05-05 03:51:47 +00:00
|
|
|
case CHAMBER_FAN_INDEX:
|
|
|
|
chamberfan_speed = fan_on ? CHAMBER_AUTO_FAN_SPEED : 0;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
#if ENABLED(AUTO_POWER_E_FANS)
|
|
|
|
autofan_speed[realFan] = fan_on ? EXTRUDER_AUTO_FAN_SPEED : 0;
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2019-03-05 06:41:31 +00:00
|
|
|
switch (f) {
|
|
|
|
#if HAS_AUTO_FAN_0
|
2019-05-05 03:51:47 +00:00
|
|
|
case 0: _UPDATE_AUTO_FAN(E0, fan_on, EXTRUDER_AUTO_FAN_SPEED); break;
|
2019-03-05 06:41:31 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_AUTO_FAN_1
|
2019-05-05 03:51:47 +00:00
|
|
|
case 1: _UPDATE_AUTO_FAN(E1, fan_on, EXTRUDER_AUTO_FAN_SPEED); break;
|
2019-03-05 06:41:31 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_AUTO_FAN_2
|
2019-05-05 03:51:47 +00:00
|
|
|
case 2: _UPDATE_AUTO_FAN(E2, fan_on, EXTRUDER_AUTO_FAN_SPEED); break;
|
2019-03-05 06:41:31 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_AUTO_FAN_3
|
2019-05-05 03:51:47 +00:00
|
|
|
case 3: _UPDATE_AUTO_FAN(E3, fan_on, EXTRUDER_AUTO_FAN_SPEED); break;
|
2019-03-05 06:41:31 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_AUTO_FAN_4
|
2019-05-05 03:51:47 +00:00
|
|
|
case 4: _UPDATE_AUTO_FAN(E4, fan_on, EXTRUDER_AUTO_FAN_SPEED); break;
|
2019-03-05 06:41:31 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_AUTO_FAN_5
|
2019-05-05 03:51:47 +00:00
|
|
|
case 5: _UPDATE_AUTO_FAN(E5, fan_on, EXTRUDER_AUTO_FAN_SPEED); break;
|
2019-03-05 06:41:31 +00:00
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
#if HAS_AUTO_FAN_6
|
|
|
|
case 6: _UPDATE_AUTO_FAN(E6, fan_on, EXTRUDER_AUTO_FAN_SPEED); break;
|
|
|
|
#endif
|
|
|
|
#if HAS_AUTO_FAN_7
|
|
|
|
case 7: _UPDATE_AUTO_FAN(E7, fan_on, EXTRUDER_AUTO_FAN_SPEED); break;
|
|
|
|
#endif
|
2019-05-05 03:51:47 +00:00
|
|
|
#if HAS_AUTO_CHAMBER_FAN && !AUTO_CHAMBER_IS_E
|
|
|
|
case CHAMBER_FAN_INDEX: _UPDATE_AUTO_FAN(CHAMBER, fan_on, CHAMBER_AUTO_FAN_SPEED); break;
|
2018-02-06 06:22:30 +00:00
|
|
|
#endif
|
2016-05-14 21:46:14 +00:00
|
|
|
}
|
2019-05-05 03:51:47 +00:00
|
|
|
SBI(fanDone, realFan);
|
2015-01-23 22:13:06 +00:00
|
|
|
}
|
2016-04-29 01:18:13 +00:00
|
|
|
}
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-06-10 00:01:47 +00:00
|
|
|
#endif // HAS_AUTO_FAN
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-02-24 12:46:11 +00:00
|
|
|
//
|
2015-03-20 05:22:23 +00:00
|
|
|
// Temperature Error Handlers
|
2015-02-24 12:46:11 +00:00
|
|
|
//
|
2019-07-10 02:35:07 +00:00
|
|
|
|
2020-09-13 23:06:14 +00:00
|
|
|
inline void loud_kill(PGM_P const lcd_msg, const heater_id_t heater_id) {
|
2020-03-14 23:47:44 +00:00
|
|
|
marlin_state = MF_KILLED;
|
2019-08-20 07:01:37 +00:00
|
|
|
#if USE_BEEPER
|
2019-07-10 02:35:07 +00:00
|
|
|
for (uint8_t i = 20; i--;) {
|
|
|
|
WRITE(BEEPER_PIN, HIGH); delay(25);
|
|
|
|
WRITE(BEEPER_PIN, LOW); delay(80);
|
|
|
|
}
|
|
|
|
WRITE(BEEPER_PIN, HIGH);
|
|
|
|
#endif
|
2020-09-13 23:06:14 +00:00
|
|
|
kill(lcd_msg, HEATER_PSTR(heater_id));
|
2019-07-10 02:35:07 +00:00
|
|
|
}
|
|
|
|
|
2020-09-13 23:06:14 +00:00
|
|
|
void Temperature::_temp_error(const heater_id_t heater_id, PGM_P const serial_msg, PGM_P const lcd_msg) {
|
2019-07-10 02:35:07 +00:00
|
|
|
|
|
|
|
static uint8_t killed = 0;
|
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
if (IsRunning() && TERN1(BOGUS_TEMPERATURE_GRACE_PERIOD, killed == 2)) {
|
2017-06-09 15:51:23 +00:00
|
|
|
SERIAL_ERROR_START();
|
2015-05-09 05:25:51 +00:00
|
|
|
serialprintPGM(serial_msg);
|
2020-02-26 09:02:03 +00:00
|
|
|
SERIAL_ECHOPGM(STR_STOPPED_HEATER);
|
2020-09-13 23:06:14 +00:00
|
|
|
if (heater_id >= 0)
|
|
|
|
SERIAL_ECHO((int)heater_id);
|
|
|
|
else if (TERN0(HAS_HEATED_CHAMBER, heater_id == H_CHAMBER))
|
2020-04-22 21:35:03 +00:00
|
|
|
SERIAL_ECHOPGM(STR_HEATER_CHAMBER);
|
|
|
|
else
|
|
|
|
SERIAL_ECHOPGM(STR_HEATER_BED);
|
2019-03-07 08:09:39 +00:00
|
|
|
SERIAL_EOL();
|
2015-03-11 23:38:42 +00:00
|
|
|
}
|
2019-05-22 02:31:05 +00:00
|
|
|
|
2019-07-10 02:35:07 +00:00
|
|
|
disable_all_heaters(); // always disable (even for bogus temp)
|
2019-05-22 02:31:05 +00:00
|
|
|
|
2019-07-10 02:35:07 +00:00
|
|
|
#if BOGUS_TEMPERATURE_GRACE_PERIOD
|
|
|
|
const millis_t ms = millis();
|
|
|
|
static millis_t expire_ms;
|
|
|
|
switch (killed) {
|
|
|
|
case 0:
|
|
|
|
expire_ms = ms + BOGUS_TEMPERATURE_GRACE_PERIOD;
|
|
|
|
++killed;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
if (ELAPSED(ms, expire_ms)) ++killed;
|
|
|
|
break;
|
|
|
|
case 2:
|
2020-09-13 23:06:14 +00:00
|
|
|
loud_kill(lcd_msg, heater_id);
|
2019-07-10 02:35:07 +00:00
|
|
|
++killed;
|
|
|
|
break;
|
2015-05-25 10:44:03 +00:00
|
|
|
}
|
2019-07-10 02:35:07 +00:00
|
|
|
#elif defined(BOGUS_TEMPERATURE_GRACE_PERIOD)
|
2019-06-18 05:15:41 +00:00
|
|
|
UNUSED(killed);
|
2019-07-10 02:35:07 +00:00
|
|
|
#else
|
2020-09-13 23:06:14 +00:00
|
|
|
if (!killed) { killed = 1; loud_kill(lcd_msg, heater_id); }
|
2015-03-11 23:38:42 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2020-09-13 23:06:14 +00:00
|
|
|
void Temperature::max_temp_error(const heater_id_t heater_id) {
|
2020-06-16 06:45:27 +00:00
|
|
|
TERN_(DWIN_CREALITY_LCD, Popup_Window_Temperature(1));
|
2020-09-13 23:06:14 +00:00
|
|
|
_temp_error(heater_id, PSTR(STR_T_MAXTEMP), GET_TEXT(MSG_ERR_MAXTEMP));
|
2015-03-11 23:38:42 +00:00
|
|
|
}
|
2018-04-23 22:13:01 +00:00
|
|
|
|
2020-09-13 23:06:14 +00:00
|
|
|
void Temperature::min_temp_error(const heater_id_t heater_id) {
|
2020-06-16 06:45:27 +00:00
|
|
|
TERN_(DWIN_CREALITY_LCD, Popup_Window_Temperature(0));
|
2020-09-13 23:06:14 +00:00
|
|
|
_temp_error(heater_id, PSTR(STR_T_MINTEMP), GET_TEXT(MSG_ERR_MINTEMP));
|
2015-03-11 23:38:42 +00:00
|
|
|
}
|
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2020-03-25 00:38:09 +00:00
|
|
|
#if ENABLED(PID_DEBUG)
|
2020-04-11 16:03:04 +00:00
|
|
|
extern bool pid_debug_flag;
|
2020-03-25 00:38:09 +00:00
|
|
|
#endif
|
2019-09-10 07:20:49 +00:00
|
|
|
|
2019-10-01 02:44:07 +00:00
|
|
|
float Temperature::get_pid_output_hotend(const uint8_t E_NAME) {
|
2019-09-10 07:20:49 +00:00
|
|
|
const uint8_t ee = HOTEND_INDEX;
|
|
|
|
#if ENABLED(PIDTEMP)
|
|
|
|
#if DISABLED(PID_OPENLOOP)
|
|
|
|
static hotend_pid_t work_pid[HOTENDS];
|
|
|
|
static float temp_iState[HOTENDS] = { 0 },
|
|
|
|
temp_dState[HOTENDS] = { 0 };
|
|
|
|
static bool pid_reset[HOTENDS] = { false };
|
|
|
|
const float pid_error = temp_hotend[ee].target - temp_hotend[ee].celsius;
|
|
|
|
|
2019-09-25 03:30:13 +00:00
|
|
|
float pid_output;
|
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
if (temp_hotend[ee].target == 0
|
|
|
|
|| pid_error < -(PID_FUNCTIONAL_RANGE)
|
2020-04-22 21:35:03 +00:00
|
|
|
|| TERN0(HEATER_IDLE_HANDLER, hotend_idle[ee].timed_out)
|
2019-09-10 07:20:49 +00:00
|
|
|
) {
|
|
|
|
pid_output = 0;
|
|
|
|
pid_reset[ee] = true;
|
2017-05-26 18:01:02 +00:00
|
|
|
}
|
2019-09-10 07:20:49 +00:00
|
|
|
else if (pid_error > PID_FUNCTIONAL_RANGE) {
|
|
|
|
pid_output = BANG_MAX;
|
|
|
|
pid_reset[ee] = true;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (pid_reset[ee]) {
|
|
|
|
temp_iState[ee] = 0.0;
|
|
|
|
work_pid[ee].Kd = 0.0;
|
|
|
|
pid_reset[ee] = false;
|
|
|
|
}
|
2019-06-22 21:52:56 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
work_pid[ee].Kd = work_pid[ee].Kd + PID_K2 * (PID_PARAM(Kd, ee) * (temp_dState[ee] - temp_hotend[ee].celsius) - work_pid[ee].Kd);
|
|
|
|
const float max_power_over_i_gain = float(PID_MAX) / PID_PARAM(Ki, ee) - float(MIN_POWER);
|
|
|
|
temp_iState[ee] = constrain(temp_iState[ee] + pid_error, 0, max_power_over_i_gain);
|
|
|
|
work_pid[ee].Kp = PID_PARAM(Kp, ee) * pid_error;
|
|
|
|
work_pid[ee].Ki = PID_PARAM(Ki, ee) * temp_iState[ee];
|
|
|
|
|
|
|
|
pid_output = work_pid[ee].Kp + work_pid[ee].Ki + work_pid[ee].Kd + float(MIN_POWER);
|
|
|
|
|
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2019-10-01 02:44:07 +00:00
|
|
|
#if HOTENDS == 1
|
|
|
|
constexpr bool this_hotend = true;
|
|
|
|
#else
|
2019-10-05 23:27:03 +00:00
|
|
|
const bool this_hotend = (ee == active_extruder);
|
2019-10-01 02:44:07 +00:00
|
|
|
#endif
|
2019-09-10 07:20:49 +00:00
|
|
|
work_pid[ee].Kc = 0;
|
2019-10-01 02:44:07 +00:00
|
|
|
if (this_hotend) {
|
2019-09-10 07:20:49 +00:00
|
|
|
const long e_position = stepper.position(E_AXIS);
|
|
|
|
if (e_position > last_e_position) {
|
|
|
|
lpq[lpq_ptr] = e_position - last_e_position;
|
|
|
|
last_e_position = e_position;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
lpq[lpq_ptr] = 0;
|
2019-03-03 11:29:55 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
if (++lpq_ptr >= lpq_len) lpq_ptr = 0;
|
|
|
|
work_pid[ee].Kc = (lpq[lpq_ptr] * planner.steps_to_mm[E_AXIS]) * PID_PARAM(Kc, ee);
|
|
|
|
pid_output += work_pid[ee].Kc;
|
|
|
|
}
|
|
|
|
#endif // PID_EXTRUSION_SCALING
|
2019-11-26 09:34:43 +00:00
|
|
|
#if ENABLED(PID_FAN_SCALING)
|
|
|
|
if (thermalManager.fan_speed[active_extruder] > PID_FAN_SCALING_MIN_SPEED) {
|
|
|
|
work_pid[ee].Kf = PID_PARAM(Kf, ee) + (PID_FAN_SCALING_LIN_FACTOR) * thermalManager.fan_speed[active_extruder];
|
|
|
|
pid_output += work_pid[ee].Kf;
|
|
|
|
}
|
|
|
|
//pid_output -= work_pid[ee].Ki;
|
|
|
|
//pid_output += work_pid[ee].Ki * work_pid[ee].Kf
|
|
|
|
#endif // PID_FAN_SCALING
|
2019-09-10 07:20:49 +00:00
|
|
|
LIMIT(pid_output, 0, PID_MAX);
|
|
|
|
}
|
|
|
|
temp_dState[ee] = temp_hotend[ee].celsius;
|
2015-08-31 02:04:30 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
#else // PID_OPENLOOP
|
2018-10-10 14:45:20 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
const float pid_output = constrain(temp_hotend[ee].target, 0, PID_MAX);
|
2018-10-10 14:45:20 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
#endif // PID_OPENLOOP
|
2015-03-14 02:49:41 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
#if ENABLED(PID_DEBUG)
|
2020-04-11 16:03:04 +00:00
|
|
|
if (ee == active_extruder && pid_debug_flag) {
|
2019-09-10 07:20:49 +00:00
|
|
|
SERIAL_ECHO_START();
|
2020-03-25 00:38:09 +00:00
|
|
|
SERIAL_ECHOPAIR(STR_PID_DEBUG, ee, STR_PID_DEBUG_INPUT, temp_hotend[ee].celsius, STR_PID_DEBUG_OUTPUT, pid_output);
|
2019-09-10 07:20:49 +00:00
|
|
|
#if DISABLED(PID_OPENLOOP)
|
2020-07-01 21:27:28 +00:00
|
|
|
{
|
2020-07-15 02:26:09 +00:00
|
|
|
SERIAL_ECHOPAIR(
|
|
|
|
STR_PID_DEBUG_PTERM, work_pid[ee].Kp,
|
|
|
|
STR_PID_DEBUG_ITERM, work_pid[ee].Ki,
|
|
|
|
STR_PID_DEBUG_DTERM, work_pid[ee].Kd
|
2019-09-10 07:20:49 +00:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2020-02-26 09:02:03 +00:00
|
|
|
, STR_PID_DEBUG_CTERM, work_pid[ee].Kc
|
2019-09-10 07:20:49 +00:00
|
|
|
#endif
|
|
|
|
);
|
2020-07-01 21:27:28 +00:00
|
|
|
}
|
2019-09-10 07:20:49 +00:00
|
|
|
#endif
|
|
|
|
SERIAL_EOL();
|
|
|
|
}
|
|
|
|
#endif // PID_DEBUG
|
2015-03-14 02:49:41 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
#else // No PID enabled
|
|
|
|
|
2020-05-18 18:58:11 +00:00
|
|
|
const bool is_idling = TERN0(HEATER_IDLE_HANDLER, hotend_idle[ee].timed_out);
|
2019-10-01 02:44:07 +00:00
|
|
|
const float pid_output = (!is_idling && temp_hotend[ee].celsius < temp_hotend[ee].target) ? BANG_MAX : 0;
|
2019-07-02 13:39:55 +00:00
|
|
|
|
2017-05-26 18:01:02 +00:00
|
|
|
#endif
|
2019-07-02 13:39:55 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
return pid_output;
|
|
|
|
}
|
2015-03-14 02:49:41 +00:00
|
|
|
|
2020-07-01 21:27:28 +00:00
|
|
|
#endif // HAS_HOTEND
|
2015-03-14 02:49:41 +00:00
|
|
|
|
2015-07-31 05:29:30 +00:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2018-10-10 14:45:20 +00:00
|
|
|
|
2016-04-29 01:18:13 +00:00
|
|
|
float Temperature::get_pid_output_bed() {
|
2018-10-10 14:45:20 +00:00
|
|
|
|
2015-07-31 05:29:30 +00:00
|
|
|
#if DISABLED(PID_OPENLOOP)
|
2015-03-14 02:49:41 +00:00
|
|
|
|
2019-09-17 23:16:28 +00:00
|
|
|
static PID_t work_pid{0};
|
2018-10-10 14:45:20 +00:00
|
|
|
static float temp_iState = 0, temp_dState = 0;
|
2019-07-28 20:50:25 +00:00
|
|
|
static bool pid_reset = true;
|
|
|
|
float pid_output = 0;
|
|
|
|
const float max_power_over_i_gain = float(MAX_BED_POWER) / temp_bed.pid.Ki - float(MIN_BED_POWER),
|
2019-09-09 07:56:23 +00:00
|
|
|
pid_error = temp_bed.target - temp_bed.celsius;
|
2019-06-22 21:52:56 +00:00
|
|
|
|
2019-07-28 20:50:25 +00:00
|
|
|
if (!temp_bed.target || pid_error < -(PID_FUNCTIONAL_RANGE)) {
|
|
|
|
pid_output = 0;
|
|
|
|
pid_reset = true;
|
|
|
|
}
|
|
|
|
else if (pid_error > PID_FUNCTIONAL_RANGE) {
|
2019-10-01 03:19:12 +00:00
|
|
|
pid_output = MAX_BED_POWER;
|
2019-07-28 20:50:25 +00:00
|
|
|
pid_reset = true;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (pid_reset) {
|
|
|
|
temp_iState = 0.0;
|
|
|
|
work_pid.Kd = 0.0;
|
|
|
|
pid_reset = false;
|
|
|
|
}
|
2019-06-22 21:52:56 +00:00
|
|
|
|
2019-07-28 20:50:25 +00:00
|
|
|
temp_iState = constrain(temp_iState + pid_error, 0, max_power_over_i_gain);
|
2018-10-10 14:45:20 +00:00
|
|
|
|
2019-07-28 20:50:25 +00:00
|
|
|
work_pid.Kp = temp_bed.pid.Kp * pid_error;
|
|
|
|
work_pid.Ki = temp_bed.pid.Ki * temp_iState;
|
2019-09-09 07:56:23 +00:00
|
|
|
work_pid.Kd = work_pid.Kd + PID_K2 * (temp_bed.pid.Kd * (temp_dState - temp_bed.celsius) - work_pid.Kd);
|
2015-03-14 02:49:41 +00:00
|
|
|
|
2019-09-09 07:56:23 +00:00
|
|
|
temp_dState = temp_bed.celsius;
|
2019-07-28 20:50:25 +00:00
|
|
|
|
|
|
|
pid_output = constrain(work_pid.Kp + work_pid.Ki + work_pid.Kd + float(MIN_BED_POWER), 0, MAX_BED_POWER);
|
|
|
|
}
|
2018-10-10 14:45:20 +00:00
|
|
|
|
|
|
|
#else // PID_OPENLOOP
|
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
const float pid_output = constrain(temp_bed.target, 0, MAX_BED_POWER);
|
2018-10-10 14:45:20 +00:00
|
|
|
|
2015-03-14 02:49:41 +00:00
|
|
|
#endif // PID_OPENLOOP
|
|
|
|
|
2015-07-31 05:29:30 +00:00
|
|
|
#if ENABLED(PID_BED_DEBUG)
|
2019-10-01 02:44:07 +00:00
|
|
|
{
|
2017-06-09 15:51:23 +00:00
|
|
|
SERIAL_ECHO_START();
|
2019-03-05 12:46:19 +00:00
|
|
|
SERIAL_ECHOLNPAIR(
|
2019-09-09 07:56:23 +00:00
|
|
|
" PID_BED_DEBUG : Input ", temp_bed.celsius, " Output ", pid_output,
|
2019-03-05 12:46:19 +00:00
|
|
|
#if DISABLED(PID_OPENLOOP)
|
2020-02-26 09:02:03 +00:00
|
|
|
STR_PID_DEBUG_PTERM, work_pid.Kp,
|
|
|
|
STR_PID_DEBUG_ITERM, work_pid.Ki,
|
|
|
|
STR_PID_DEBUG_DTERM, work_pid.Kd,
|
2019-03-05 12:46:19 +00:00
|
|
|
#endif
|
|
|
|
);
|
2019-10-01 02:44:07 +00:00
|
|
|
}
|
2018-10-10 14:45:20 +00:00
|
|
|
#endif
|
2015-03-19 23:07:36 +00:00
|
|
|
|
2015-03-14 02:49:41 +00:00
|
|
|
return pid_output;
|
|
|
|
}
|
2018-10-10 14:45:20 +00:00
|
|
|
|
2017-05-09 17:35:43 +00:00
|
|
|
#endif // PIDTEMPBED
|
2015-03-14 02:49:41 +00:00
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
/**
|
|
|
|
* Manage heating activities for extruder hot-ends and a heated bed
|
|
|
|
* - Acquire updated temperature readings
|
2016-05-15 00:37:42 +00:00
|
|
|
* - Also resets the watchdog timer
|
2015-04-14 00:17:36 +00:00
|
|
|
* - Invoke thermal runaway protection
|
|
|
|
* - Manage extruder auto-fan
|
|
|
|
* - Apply filament width to the extrusion rate (may move)
|
|
|
|
* - Update the heated bed PID output value
|
|
|
|
*/
|
2016-04-29 01:18:13 +00:00
|
|
|
void Temperature::manage_heater() {
|
2011-12-06 04:33:33 +00:00
|
|
|
|
2018-03-22 00:04:45 +00:00
|
|
|
#if EARLY_WATCHDOG
|
|
|
|
// If thermal manager is still not running, make sure to at least reset the watchdog!
|
2019-09-29 22:57:29 +00:00
|
|
|
if (!inited) return watchdog_refresh();
|
2018-03-22 00:04:45 +00:00
|
|
|
#endif
|
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
if (TERN0(EMERGENCY_PARSER, emergency_parser.killed_by_M112))
|
|
|
|
kill(M112_KILL_STR, nullptr, true);
|
2018-03-04 05:14:01 +00:00
|
|
|
|
2020-01-26 23:39:45 +00:00
|
|
|
if (!raw_temps_ready) return;
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2016-05-15 00:37:42 +00:00
|
|
|
updateTemperaturesFromRawValues(); // also resets the watchdog
|
2011-11-15 21:50:43 +00:00
|
|
|
|
2020-07-11 05:23:48 +00:00
|
|
|
#if DISABLED(IGNORE_THERMOCOUPLE_ERRORS)
|
|
|
|
#if ENABLED(HEATER_0_USES_MAX6675)
|
|
|
|
if (temp_hotend[0].celsius > _MIN(HEATER_0_MAXTEMP, HEATER_0_MAX6675_TMAX - 1.0)) max_temp_error(H_E0);
|
|
|
|
if (temp_hotend[0].celsius < _MAX(HEATER_0_MINTEMP, HEATER_0_MAX6675_TMIN + .01)) min_temp_error(H_E0);
|
|
|
|
#endif
|
|
|
|
#if ENABLED(HEATER_1_USES_MAX6675)
|
|
|
|
if (temp_hotend[1].celsius > _MIN(HEATER_1_MAXTEMP, HEATER_1_MAX6675_TMAX - 1.0)) max_temp_error(H_E1);
|
|
|
|
if (temp_hotend[1].celsius < _MAX(HEATER_1_MINTEMP, HEATER_1_MAX6675_TMIN + .01)) min_temp_error(H_E1);
|
|
|
|
#endif
|
2015-05-09 05:25:51 +00:00
|
|
|
#endif
|
2015-03-25 10:08:24 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
millis_t ms = millis();
|
2011-12-06 04:33:33 +00:00
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2014-06-30 18:22:37 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
HOTEND_LOOP() {
|
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS)
|
|
|
|
if (degHotend(e) > temp_range[e].maxtemp)
|
2020-09-13 23:06:14 +00:00
|
|
|
_temp_error((heater_id_t)e, str_t_thermal_runaway, GET_TEXT(MSG_THERMAL_RUNAWAY));
|
2019-09-10 07:20:49 +00:00
|
|
|
#endif
|
2017-05-26 18:01:02 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HEATER_IDLE_HANDLER, hotend_idle[e].update(ms));
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS)
|
|
|
|
// Check for thermal runaway
|
2020-09-13 23:06:14 +00:00
|
|
|
thermal_runaway_protection(tr_state_machine[e], temp_hotend[e].celsius, temp_hotend[e].target, (heater_id_t)e, THERMAL_PROTECTION_PERIOD, THERMAL_PROTECTION_HYSTERESIS);
|
2019-09-10 07:20:49 +00:00
|
|
|
#endif
|
2011-12-06 04:33:33 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
temp_hotend[e].soft_pwm_amount = (temp_hotend[e].celsius > temp_range[e].mintemp || is_preheating(e)) && temp_hotend[e].celsius < temp_range[e].maxtemp ? (int)get_pid_output_hotend(e) >> 1 : 0;
|
2015-05-13 01:22:47 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
#if WATCH_HOTENDS
|
|
|
|
// Make sure temperature is increasing
|
2020-01-26 23:39:45 +00:00
|
|
|
if (watch_hotend[e].next_ms && ELAPSED(ms, watch_hotend[e].next_ms)) { // Time to check this extruder?
|
2020-06-16 06:45:27 +00:00
|
|
|
if (degHotend(e) < watch_hotend[e].target) { // Failed to increase enough?
|
|
|
|
TERN_(DWIN_CREALITY_LCD, Popup_Window_Temperature(0));
|
2020-09-13 23:06:14 +00:00
|
|
|
_temp_error((heater_id_t)e, str_t_heating_failed, GET_TEXT(MSG_HEATING_FAILED_LCD));
|
2020-06-16 06:45:27 +00:00
|
|
|
}
|
2020-01-26 23:39:45 +00:00
|
|
|
else // Start again if the target is still far off
|
2019-09-10 07:20:49 +00:00
|
|
|
start_watching_hotend(e);
|
|
|
|
}
|
|
|
|
#endif
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
|
|
|
// Make sure measured temperatures are close together
|
|
|
|
if (ABS(temp_hotend[0].celsius - redundant_temperature) > MAX_REDUNDANT_TEMP_SENSOR_DIFF)
|
2020-02-26 09:02:03 +00:00
|
|
|
_temp_error(H_E0, PSTR(STR_REDUNDANCY), GET_TEXT(MSG_ERR_REDUNDANT_TEMP));
|
2019-09-10 07:20:49 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
} // HOTEND_LOOP
|
|
|
|
|
2020-07-01 21:27:28 +00:00
|
|
|
#endif // HAS_HOTEND
|
2012-08-11 06:17:47 +00:00
|
|
|
|
2015-02-26 09:14:59 +00:00
|
|
|
#if HAS_AUTO_FAN
|
2016-04-12 01:48:27 +00:00
|
|
|
if (ELAPSED(ms, next_auto_fan_check_ms)) { // only need to check fan state very infrequently
|
2015-02-24 12:46:11 +00:00
|
|
|
checkExtruderAutoFans();
|
2016-04-10 22:55:12 +00:00
|
|
|
next_auto_fan_check_ms = ms + 2500UL;
|
2015-02-24 12:46:11 +00:00
|
|
|
}
|
2015-10-03 06:08:58 +00:00
|
|
|
#endif
|
2015-04-14 00:17:36 +00:00
|
|
|
|
2016-03-30 03:28:23 +00:00
|
|
|
#if ENABLED(FILAMENT_WIDTH_SENSOR)
|
2017-12-13 08:32:34 +00:00
|
|
|
/**
|
2019-09-10 23:48:58 +00:00
|
|
|
* Dynamically set the volumetric multiplier based
|
|
|
|
* on the delayed Filament Width measurement.
|
2017-12-13 08:32:34 +00:00
|
|
|
*/
|
2019-09-10 23:48:58 +00:00
|
|
|
filwidth.update_volumetric();
|
|
|
|
#endif
|
2015-04-14 00:17:36 +00:00
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
|
|
|
|
2019-04-22 01:50:32 +00:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_BED)
|
2019-08-06 01:33:15 +00:00
|
|
|
if (degBed() > BED_MAXTEMP)
|
2020-02-26 09:02:03 +00:00
|
|
|
_temp_error(H_BED, str_t_thermal_runaway, GET_TEXT(MSG_THERMAL_RUNAWAY));
|
2019-04-22 01:50:32 +00:00
|
|
|
#endif
|
2019-04-20 02:37:12 +00:00
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
#if WATCH_BED
|
2018-04-23 22:13:01 +00:00
|
|
|
// Make sure temperature is increasing
|
2019-03-07 08:09:39 +00:00
|
|
|
if (watch_bed.elapsed(ms)) { // Time to check the bed?
|
2020-06-16 06:45:27 +00:00
|
|
|
if (degBed() < watch_bed.target) { // Failed to increase enough?
|
|
|
|
TERN_(DWIN_CREALITY_LCD, Popup_Window_Temperature(0));
|
2020-02-26 09:02:03 +00:00
|
|
|
_temp_error(H_BED, str_t_heating_failed, GET_TEXT(MSG_HEATING_FAILED_LCD));
|
2020-06-16 06:45:27 +00:00
|
|
|
}
|
2018-04-23 22:13:01 +00:00
|
|
|
else // Start again if the target is still far off
|
|
|
|
start_watching_bed();
|
|
|
|
}
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif // WATCH_BED
|
2017-05-26 18:01:02 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
#if BOTH(PROBING_HEATERS_OFF, BED_LIMIT_SWITCHING)
|
|
|
|
#define PAUSE_CHANGE_REQD 1
|
|
|
|
#endif
|
|
|
|
|
2020-03-08 04:34:33 +00:00
|
|
|
#if PAUSE_CHANGE_REQD
|
|
|
|
static bool last_pause_state;
|
|
|
|
#endif
|
|
|
|
|
2019-05-07 00:55:01 +00:00
|
|
|
do {
|
|
|
|
|
|
|
|
#if DISABLED(PIDTEMPBED)
|
|
|
|
if (PENDING(ms, next_bed_check_ms)
|
2020-04-22 21:35:03 +00:00
|
|
|
&& TERN1(PAUSE_CHANGE_REQD, paused == last_pause_state)
|
2019-05-07 00:55:01 +00:00
|
|
|
) break;
|
|
|
|
next_bed_check_ms = ms + BED_CHECK_INTERVAL;
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(PAUSE_CHANGE_REQD, last_pause_state = paused);
|
2018-02-09 02:36:05 +00:00
|
|
|
#endif
|
2017-05-26 18:01:02 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HEATER_IDLE_HANDLER, bed_idle.update(ms));
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HAS_THERMALLY_PROTECTED_BED, thermal_runaway_protection(tr_state_machine_bed, temp_bed.celsius, temp_bed.target, H_BED, THERMAL_PROTECTION_BED_PERIOD, THERMAL_PROTECTION_BED_HYSTERESIS));
|
2014-06-30 18:22:37 +00:00
|
|
|
|
2019-05-07 00:55:01 +00:00
|
|
|
#if HEATER_IDLE_HANDLER
|
|
|
|
if (bed_idle.timed_out) {
|
2019-03-07 08:09:39 +00:00
|
|
|
temp_bed.soft_pwm_amount = 0;
|
2019-05-07 00:55:01 +00:00
|
|
|
#if DISABLED(PIDTEMPBED)
|
|
|
|
WRITE_HEATER_BED(LOW);
|
|
|
|
#endif
|
2017-05-26 18:01:02 +00:00
|
|
|
}
|
2019-05-07 00:55:01 +00:00
|
|
|
else
|
2017-05-26 18:01:02 +00:00
|
|
|
#endif
|
2019-05-07 00:55:01 +00:00
|
|
|
{
|
|
|
|
#if ENABLED(PIDTEMPBED)
|
2019-09-09 07:56:23 +00:00
|
|
|
temp_bed.soft_pwm_amount = WITHIN(temp_bed.celsius, BED_MINTEMP, BED_MAXTEMP) ? (int)get_pid_output_bed() >> 1 : 0;
|
2019-05-07 00:55:01 +00:00
|
|
|
#else
|
|
|
|
// Check if temperature is within the correct band
|
2019-09-09 07:56:23 +00:00
|
|
|
if (WITHIN(temp_bed.celsius, BED_MINTEMP, BED_MAXTEMP)) {
|
2019-05-07 00:55:01 +00:00
|
|
|
#if ENABLED(BED_LIMIT_SWITCHING)
|
2019-09-09 07:56:23 +00:00
|
|
|
if (temp_bed.celsius >= temp_bed.target + BED_HYSTERESIS)
|
2019-05-07 00:55:01 +00:00
|
|
|
temp_bed.soft_pwm_amount = 0;
|
2019-09-09 07:56:23 +00:00
|
|
|
else if (temp_bed.celsius <= temp_bed.target - (BED_HYSTERESIS))
|
2019-05-07 00:55:01 +00:00
|
|
|
temp_bed.soft_pwm_amount = MAX_BED_POWER >> 1;
|
|
|
|
#else // !PIDTEMPBED && !BED_LIMIT_SWITCHING
|
2019-09-09 07:56:23 +00:00
|
|
|
temp_bed.soft_pwm_amount = temp_bed.celsius < temp_bed.target ? MAX_BED_POWER >> 1 : 0;
|
2019-05-07 00:55:01 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
temp_bed.soft_pwm_amount = 0;
|
|
|
|
WRITE_HEATER_BED(LOW);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
} while (false);
|
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#endif // HAS_HEATED_BED
|
2019-03-07 08:09:39 +00:00
|
|
|
|
2019-05-05 03:51:47 +00:00
|
|
|
#if HAS_HEATED_CHAMBER
|
2019-03-07 08:09:39 +00:00
|
|
|
|
|
|
|
#ifndef CHAMBER_CHECK_INTERVAL
|
|
|
|
#define CHAMBER_CHECK_INTERVAL 1000UL
|
|
|
|
#endif
|
|
|
|
|
2019-05-05 03:51:47 +00:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_CHAMBER)
|
2019-08-06 01:33:15 +00:00
|
|
|
if (degChamber() > CHAMBER_MAXTEMP)
|
2020-02-26 09:02:03 +00:00
|
|
|
_temp_error(H_CHAMBER, str_t_thermal_runaway, GET_TEXT(MSG_THERMAL_RUNAWAY));
|
2019-05-05 03:51:47 +00:00
|
|
|
#endif
|
2019-03-07 08:09:39 +00:00
|
|
|
|
2019-05-05 03:51:47 +00:00
|
|
|
#if WATCH_CHAMBER
|
|
|
|
// Make sure temperature is increasing
|
2019-05-07 00:55:01 +00:00
|
|
|
if (watch_chamber.elapsed(ms)) { // Time to check the chamber?
|
|
|
|
if (degChamber() < watch_chamber.target) // Failed to increase enough?
|
2020-02-26 09:02:03 +00:00
|
|
|
_temp_error(H_CHAMBER, str_t_heating_failed, GET_TEXT(MSG_HEATING_FAILED_LCD));
|
2019-05-05 03:51:47 +00:00
|
|
|
else
|
2019-05-07 00:55:01 +00:00
|
|
|
start_watching_chamber(); // Start again if the target is still far off
|
2019-03-07 08:09:39 +00:00
|
|
|
}
|
2019-05-07 00:55:01 +00:00
|
|
|
#endif
|
2019-05-05 03:51:47 +00:00
|
|
|
|
2019-05-07 00:55:01 +00:00
|
|
|
if (ELAPSED(ms, next_chamber_check_ms)) {
|
|
|
|
next_chamber_check_ms = ms + CHAMBER_CHECK_INTERVAL;
|
2019-03-07 08:09:39 +00:00
|
|
|
|
2019-09-09 07:56:23 +00:00
|
|
|
if (WITHIN(temp_chamber.celsius, CHAMBER_MINTEMP, CHAMBER_MAXTEMP)) {
|
2019-05-07 00:55:01 +00:00
|
|
|
#if ENABLED(CHAMBER_LIMIT_SWITCHING)
|
2019-09-09 07:56:23 +00:00
|
|
|
if (temp_chamber.celsius >= temp_chamber.target + TEMP_CHAMBER_HYSTERESIS)
|
2019-05-07 00:55:01 +00:00
|
|
|
temp_chamber.soft_pwm_amount = 0;
|
2019-09-09 07:56:23 +00:00
|
|
|
else if (temp_chamber.celsius <= temp_chamber.target - (TEMP_CHAMBER_HYSTERESIS))
|
2019-05-07 00:55:01 +00:00
|
|
|
temp_chamber.soft_pwm_amount = MAX_CHAMBER_POWER >> 1;
|
|
|
|
#else
|
2019-09-09 07:56:23 +00:00
|
|
|
temp_chamber.soft_pwm_amount = temp_chamber.celsius < temp_chamber.target ? MAX_CHAMBER_POWER >> 1 : 0;
|
2019-05-07 00:55:01 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
temp_chamber.soft_pwm_amount = 0;
|
|
|
|
WRITE_HEATER_CHAMBER(LOW);
|
|
|
|
}
|
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(THERMAL_PROTECTION_CHAMBER, thermal_runaway_protection(tr_state_machine_chamber, temp_chamber.celsius, temp_chamber.target, H_CHAMBER, THERMAL_PROTECTION_CHAMBER_PERIOD, THERMAL_PROTECTION_CHAMBER_HYSTERESIS));
|
2019-05-05 03:51:47 +00:00
|
|
|
}
|
2019-03-07 08:09:39 +00:00
|
|
|
|
2019-05-05 03:51:47 +00:00
|
|
|
// TODO: Implement true PID pwm
|
2019-09-09 07:56:23 +00:00
|
|
|
//temp_bed.soft_pwm_amount = WITHIN(temp_chamber.celsius, CHAMBER_MINTEMP, CHAMBER_MAXTEMP) ? (int)get_pid_output_chamber() >> 1 : 0;
|
2019-03-07 08:09:39 +00:00
|
|
|
|
2019-05-05 03:51:47 +00:00
|
|
|
#endif // HAS_HEATED_CHAMBER
|
2019-09-10 07:20:49 +00:00
|
|
|
|
|
|
|
UNUSED(ms);
|
2011-11-15 21:50:43 +00:00
|
|
|
}
|
|
|
|
|
2020-02-29 05:28:17 +00:00
|
|
|
#define TEMP_AD595(RAW) ((RAW) * 5.0 * 100.0 / float(HAL_ADC_RANGE) / (OVERSAMPLENR) * (TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET)
|
|
|
|
#define TEMP_AD8495(RAW) ((RAW) * 6.6 * 100.0 / float(HAL_ADC_RANGE) / (OVERSAMPLENR) * (TEMP_SENSOR_AD8495_GAIN) + TEMP_SENSOR_AD8495_OFFSET)
|
2018-05-11 06:01:51 +00:00
|
|
|
|
2018-05-28 04:27:51 +00:00
|
|
|
/**
|
|
|
|
* Bisect search for the range of the 'raw' value, then interpolate
|
|
|
|
* proportionally between the under and over values.
|
|
|
|
*/
|
2020-07-01 21:27:28 +00:00
|
|
|
#define SCAN_THERMISTOR_TABLE(TBL,LEN) do{ \
|
|
|
|
uint8_t l = 0, r = LEN, m; \
|
|
|
|
for (;;) { \
|
|
|
|
m = (l + r) >> 1; \
|
|
|
|
if (!m) return int16_t(pgm_read_word(&TBL[0].celsius)); \
|
|
|
|
if (m == l || m == r) return int16_t(pgm_read_word(&TBL[LEN-1].celsius)); \
|
|
|
|
int16_t v00 = pgm_read_word(&TBL[m-1].value), \
|
|
|
|
v10 = pgm_read_word(&TBL[m-0].value); \
|
|
|
|
if (raw < v00) r = m; \
|
|
|
|
else if (raw > v10) l = m; \
|
|
|
|
else { \
|
|
|
|
const int16_t v01 = int16_t(pgm_read_word(&TBL[m-1].celsius)), \
|
|
|
|
v11 = int16_t(pgm_read_word(&TBL[m-0].celsius)); \
|
|
|
|
return v01 + (raw - v00) * float(v11 - v01) / float(v10 - v00); \
|
|
|
|
} \
|
|
|
|
} \
|
2018-05-11 06:01:51 +00:00
|
|
|
}while(0)
|
2016-04-29 01:18:13 +00:00
|
|
|
|
2019-05-06 23:51:06 +00:00
|
|
|
#if HAS_USER_THERMISTORS
|
|
|
|
|
|
|
|
user_thermistor_t Temperature::user_thermistor[USER_THERMISTORS]; // Initialized by settings.load()
|
|
|
|
|
|
|
|
void Temperature::reset_user_thermistors() {
|
|
|
|
user_thermistor_t user_thermistor[USER_THERMISTORS] = {
|
|
|
|
#if ENABLED(HEATER_0_USER_THERMISTOR)
|
|
|
|
{ true, 0, 0, HOTEND0_PULLUP_RESISTOR_OHMS, HOTEND0_RESISTANCE_25C_OHMS, 0, 0, HOTEND0_BETA, 0 },
|
|
|
|
#endif
|
|
|
|
#if ENABLED(HEATER_1_USER_THERMISTOR)
|
|
|
|
{ true, 0, 0, HOTEND1_PULLUP_RESISTOR_OHMS, HOTEND1_RESISTANCE_25C_OHMS, 0, 0, HOTEND1_BETA, 0 },
|
|
|
|
#endif
|
|
|
|
#if ENABLED(HEATER_2_USER_THERMISTOR)
|
|
|
|
{ true, 0, 0, HOTEND2_PULLUP_RESISTOR_OHMS, HOTEND2_RESISTANCE_25C_OHMS, 0, 0, HOTEND2_BETA, 0 },
|
|
|
|
#endif
|
|
|
|
#if ENABLED(HEATER_3_USER_THERMISTOR)
|
|
|
|
{ true, 0, 0, HOTEND3_PULLUP_RESISTOR_OHMS, HOTEND3_RESISTANCE_25C_OHMS, 0, 0, HOTEND3_BETA, 0 },
|
|
|
|
#endif
|
|
|
|
#if ENABLED(HEATER_4_USER_THERMISTOR)
|
|
|
|
{ true, 0, 0, HOTEND4_PULLUP_RESISTOR_OHMS, HOTEND4_RESISTANCE_25C_OHMS, 0, 0, HOTEND4_BETA, 0 },
|
|
|
|
#endif
|
|
|
|
#if ENABLED(HEATER_5_USER_THERMISTOR)
|
|
|
|
{ true, 0, 0, HOTEND5_PULLUP_RESISTOR_OHMS, HOTEND5_RESISTANCE_25C_OHMS, 0, 0, HOTEND5_BETA, 0 },
|
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
#if ENABLED(HEATER_6_USER_THERMISTOR)
|
|
|
|
{ true, 0, 0, HOTEND6_PULLUP_RESISTOR_OHMS, HOTEND6_RESISTANCE_25C_OHMS, 0, 0, HOTEND6_BETA, 0 },
|
|
|
|
#endif
|
|
|
|
#if ENABLED(HEATER_7_USER_THERMISTOR)
|
|
|
|
{ true, 0, 0, HOTEND7_PULLUP_RESISTOR_OHMS, HOTEND7_RESISTANCE_25C_OHMS, 0, 0, HOTEND7_BETA, 0 },
|
|
|
|
#endif
|
2019-05-28 22:43:31 +00:00
|
|
|
#if ENABLED(HEATER_BED_USER_THERMISTOR)
|
2019-05-06 23:51:06 +00:00
|
|
|
{ true, 0, 0, BED_PULLUP_RESISTOR_OHMS, BED_RESISTANCE_25C_OHMS, 0, 0, BED_BETA, 0 },
|
|
|
|
#endif
|
2019-05-28 22:43:31 +00:00
|
|
|
#if ENABLED(HEATER_CHAMBER_USER_THERMISTOR)
|
2019-05-06 23:51:06 +00:00
|
|
|
{ true, 0, 0, CHAMBER_PULLUP_RESISTOR_OHMS, CHAMBER_RESISTANCE_25C_OHMS, 0, 0, CHAMBER_BETA, 0 }
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
COPY(thermalManager.user_thermistor, user_thermistor);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Temperature::log_user_thermistor(const uint8_t t_index, const bool eprom/*=false*/) {
|
|
|
|
|
|
|
|
if (eprom)
|
|
|
|
SERIAL_ECHOPGM(" M305 ");
|
|
|
|
else
|
|
|
|
SERIAL_ECHO_START();
|
|
|
|
SERIAL_CHAR('P');
|
|
|
|
SERIAL_CHAR('0' + t_index);
|
|
|
|
|
|
|
|
const user_thermistor_t &t = user_thermistor[t_index];
|
|
|
|
|
|
|
|
SERIAL_ECHOPAIR_F(" R", t.series_res, 1);
|
2020-02-01 23:05:42 +00:00
|
|
|
SERIAL_ECHOPAIR_F_P(SP_T_STR, t.res_25, 1);
|
2020-06-28 04:27:28 +00:00
|
|
|
SERIAL_ECHOPAIR_F_P(SP_B_STR, t.beta, 1);
|
|
|
|
SERIAL_ECHOPAIR_F_P(SP_C_STR, t.sh_c_coeff, 9);
|
2019-05-06 23:51:06 +00:00
|
|
|
SERIAL_ECHOPGM(" ; ");
|
|
|
|
serialprintPGM(
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HEATER_0_USER_THERMISTOR, t_index == CTI_HOTEND_0 ? PSTR("HOTEND 0") :)
|
|
|
|
TERN_(HEATER_1_USER_THERMISTOR, t_index == CTI_HOTEND_1 ? PSTR("HOTEND 1") :)
|
|
|
|
TERN_(HEATER_2_USER_THERMISTOR, t_index == CTI_HOTEND_2 ? PSTR("HOTEND 2") :)
|
|
|
|
TERN_(HEATER_3_USER_THERMISTOR, t_index == CTI_HOTEND_3 ? PSTR("HOTEND 3") :)
|
|
|
|
TERN_(HEATER_4_USER_THERMISTOR, t_index == CTI_HOTEND_4 ? PSTR("HOTEND 4") :)
|
|
|
|
TERN_(HEATER_5_USER_THERMISTOR, t_index == CTI_HOTEND_5 ? PSTR("HOTEND 5") :)
|
|
|
|
TERN_(HEATER_6_USER_THERMISTOR, t_index == CTI_HOTEND_6 ? PSTR("HOTEND 6") :)
|
|
|
|
TERN_(HEATER_7_USER_THERMISTOR, t_index == CTI_HOTEND_7 ? PSTR("HOTEND 7") :)
|
|
|
|
TERN_(HEATER_BED_USER_THERMISTOR, t_index == CTI_BED ? PSTR("BED") :)
|
|
|
|
TERN_(HEATER_CHAMBER_USER_THERMISTOR, t_index == CTI_CHAMBER ? PSTR("CHAMBER") :)
|
2019-05-09 16:45:55 +00:00
|
|
|
nullptr
|
2019-05-06 23:51:06 +00:00
|
|
|
);
|
|
|
|
SERIAL_EOL();
|
|
|
|
}
|
|
|
|
|
|
|
|
float Temperature::user_thermistor_to_deg_c(const uint8_t t_index, const int raw) {
|
|
|
|
//#if (MOTHERBOARD == BOARD_RAMPS_14_EFB)
|
|
|
|
// static uint32_t clocks_total = 0;
|
|
|
|
// static uint32_t calls = 0;
|
|
|
|
// uint32_t tcnt5 = TCNT5;
|
|
|
|
//#endif
|
|
|
|
|
|
|
|
if (!WITHIN(t_index, 0, COUNT(user_thermistor) - 1)) return 25;
|
|
|
|
|
2019-09-14 08:05:10 +00:00
|
|
|
user_thermistor_t &t = user_thermistor[t_index];
|
|
|
|
if (t.pre_calc) { // pre-calculate some variables
|
|
|
|
t.pre_calc = false;
|
|
|
|
t.res_25_recip = 1.0f / t.res_25;
|
|
|
|
t.res_25_log = logf(t.res_25);
|
|
|
|
t.beta_recip = 1.0f / t.beta;
|
|
|
|
t.sh_alpha = RECIPROCAL(THERMISTOR_RESISTANCE_NOMINAL_C - (THERMISTOR_ABS_ZERO_C))
|
|
|
|
- (t.beta_recip * t.res_25_log) - (t.sh_c_coeff * cu(t.res_25_log));
|
2019-05-06 23:51:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// maximum adc value .. take into account the over sampling
|
2019-11-06 23:49:17 +00:00
|
|
|
const int adc_max = MAX_RAW_THERMISTOR_VALUE,
|
2019-05-06 23:51:06 +00:00
|
|
|
adc_raw = constrain(raw, 1, adc_max - 1); // constrain to prevent divide-by-zero
|
|
|
|
|
|
|
|
const float adc_inverse = (adc_max - adc_raw) - 0.5f,
|
2019-09-14 08:05:10 +00:00
|
|
|
resistance = t.series_res * (adc_raw + 0.5f) / adc_inverse,
|
2019-05-06 23:51:06 +00:00
|
|
|
log_resistance = logf(resistance);
|
|
|
|
|
2019-09-14 08:05:10 +00:00
|
|
|
float value = t.sh_alpha;
|
|
|
|
value += log_resistance * t.beta_recip;
|
|
|
|
if (t.sh_c_coeff != 0)
|
|
|
|
value += t.sh_c_coeff * cu(log_resistance);
|
2019-05-06 23:51:06 +00:00
|
|
|
value = 1.0f / value;
|
|
|
|
|
|
|
|
//#if (MOTHERBOARD == BOARD_RAMPS_14_EFB)
|
|
|
|
// int32_t clocks = TCNT5 - tcnt5;
|
|
|
|
// if (clocks >= 0) {
|
|
|
|
// clocks_total += clocks;
|
|
|
|
// calls++;
|
|
|
|
// }
|
|
|
|
//#endif
|
|
|
|
|
2019-05-22 02:31:05 +00:00
|
|
|
// Return degrees C (up to 999, as the LCD only displays 3 digits)
|
2019-07-05 23:01:21 +00:00
|
|
|
return _MIN(value + THERMISTOR_ABS_ZERO_C, 999);
|
2019-05-06 23:51:06 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-09-10 07:20:49 +00:00
|
|
|
// Derived from RepRap FiveD extruder::getTemperature()
|
|
|
|
// For hot end temperature measurement.
|
|
|
|
float Temperature::analog_to_celsius_hotend(const int raw, const uint8_t e) {
|
2020-04-22 21:35:03 +00:00
|
|
|
if (e > HOTENDS - DISABLED(TEMP_SENSOR_1_AS_REDUNDANT)) {
|
2019-09-10 07:20:49 +00:00
|
|
|
SERIAL_ERROR_START();
|
|
|
|
SERIAL_ECHO((int)e);
|
2020-02-26 09:02:03 +00:00
|
|
|
SERIAL_ECHOLNPGM(STR_INVALID_EXTRUDER_NUM);
|
2019-09-10 07:20:49 +00:00
|
|
|
kill();
|
2020-01-17 23:16:45 +00:00
|
|
|
return 0;
|
2019-09-10 07:20:49 +00:00
|
|
|
}
|
2015-04-14 00:17:36 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
switch (e) {
|
|
|
|
case 0:
|
|
|
|
#if ENABLED(HEATER_0_USER_THERMISTOR)
|
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_0, raw);
|
|
|
|
#elif ENABLED(HEATER_0_USES_MAX6675)
|
2019-11-21 09:15:10 +00:00
|
|
|
return (
|
|
|
|
#if ENABLED(MAX6675_IS_MAX31865)
|
|
|
|
max31865.temperature(100, 400) // 100 ohms = PT100 resistance. 400 ohms = calibration resistor
|
|
|
|
#else
|
|
|
|
raw * 0.25
|
|
|
|
#endif
|
|
|
|
);
|
2019-09-10 07:20:49 +00:00
|
|
|
#elif ENABLED(HEATER_0_USES_AD595)
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif ENABLED(HEATER_0_USES_AD8495)
|
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 1:
|
|
|
|
#if ENABLED(HEATER_1_USER_THERMISTOR)
|
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_1, raw);
|
|
|
|
#elif ENABLED(HEATER_1_USES_MAX6675)
|
|
|
|
return raw * 0.25;
|
|
|
|
#elif ENABLED(HEATER_1_USES_AD595)
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif ENABLED(HEATER_1_USES_AD8495)
|
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 2:
|
|
|
|
#if ENABLED(HEATER_2_USER_THERMISTOR)
|
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_2, raw);
|
|
|
|
#elif ENABLED(HEATER_2_USES_AD595)
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif ENABLED(HEATER_2_USES_AD8495)
|
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 3:
|
|
|
|
#if ENABLED(HEATER_3_USER_THERMISTOR)
|
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_3, raw);
|
|
|
|
#elif ENABLED(HEATER_3_USES_AD595)
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif ENABLED(HEATER_3_USES_AD8495)
|
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 4:
|
|
|
|
#if ENABLED(HEATER_4_USER_THERMISTOR)
|
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_4, raw);
|
|
|
|
#elif ENABLED(HEATER_4_USES_AD595)
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif ENABLED(HEATER_4_USES_AD8495)
|
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 5:
|
|
|
|
#if ENABLED(HEATER_5_USER_THERMISTOR)
|
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_5, raw);
|
|
|
|
#elif ENABLED(HEATER_5_USES_AD595)
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif ENABLED(HEATER_5_USES_AD8495)
|
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
case 6:
|
|
|
|
#if ENABLED(HEATER_6_USER_THERMISTOR)
|
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_6, raw);
|
|
|
|
#elif ENABLED(HEATER_6_USES_AD595)
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif ENABLED(HEATER_6_USES_AD8495)
|
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 7:
|
|
|
|
#if ENABLED(HEATER_7_USER_THERMISTOR)
|
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_7, raw);
|
|
|
|
#elif ENABLED(HEATER_7_USES_AD595)
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif ENABLED(HEATER_7_USES_AD8495)
|
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
2019-09-10 07:20:49 +00:00
|
|
|
default: break;
|
|
|
|
}
|
2018-05-02 00:33:41 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
#if HOTEND_USES_THERMISTOR
|
|
|
|
// Thermistor with conversion table?
|
2020-07-01 21:27:28 +00:00
|
|
|
const temp_entry_t(*tt)[] = (temp_entry_t(*)[])(heater_ttbl_map[e]);
|
2019-09-10 07:20:49 +00:00
|
|
|
SCAN_THERMISTOR_TABLE((*tt), heater_ttbllen_map[e]);
|
|
|
|
#endif
|
2018-05-12 10:27:51 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2020-07-01 21:27:28 +00:00
|
|
|
#endif // HAS_HOTEND
|
2011-11-15 21:50:43 +00:00
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2018-01-02 00:24:54 +00:00
|
|
|
// Derived from RepRap FiveD extruder::getTemperature()
|
|
|
|
// For bed temperature measurement.
|
2018-11-14 19:13:51 +00:00
|
|
|
float Temperature::analog_to_celsius_bed(const int raw) {
|
2019-05-28 22:43:31 +00:00
|
|
|
#if ENABLED(HEATER_BED_USER_THERMISTOR)
|
2019-05-06 23:51:06 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_BED, raw);
|
|
|
|
#elif ENABLED(HEATER_BED_USES_THERMISTOR)
|
2019-05-26 06:30:15 +00:00
|
|
|
SCAN_THERMISTOR_TABLE(BED_TEMPTABLE, BED_TEMPTABLE_LEN);
|
2018-05-11 06:01:51 +00:00
|
|
|
#elif ENABLED(HEATER_BED_USES_AD595)
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif ENABLED(HEATER_BED_USES_AD8495)
|
|
|
|
return TEMP_AD8495(raw);
|
2018-01-02 00:24:54 +00:00
|
|
|
#else
|
2020-01-17 23:16:45 +00:00
|
|
|
UNUSED(raw);
|
2018-05-11 06:01:51 +00:00
|
|
|
return 0;
|
2018-01-02 00:24:54 +00:00
|
|
|
#endif
|
|
|
|
}
|
2018-04-23 22:13:01 +00:00
|
|
|
#endif // HAS_HEATED_BED
|
2011-11-15 21:50:43 +00:00
|
|
|
|
2018-02-24 06:38:58 +00:00
|
|
|
#if HAS_TEMP_CHAMBER
|
|
|
|
// Derived from RepRap FiveD extruder::getTemperature()
|
|
|
|
// For chamber temperature measurement.
|
2019-03-07 08:09:39 +00:00
|
|
|
float Temperature::analog_to_celsius_chamber(const int raw) {
|
2019-05-28 22:43:31 +00:00
|
|
|
#if ENABLED(HEATER_CHAMBER_USER_THERMISTOR)
|
2019-05-06 23:51:06 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_CHAMBER, raw);
|
|
|
|
#elif ENABLED(HEATER_CHAMBER_USES_THERMISTOR)
|
2019-05-26 06:30:15 +00:00
|
|
|
SCAN_THERMISTOR_TABLE(CHAMBER_TEMPTABLE, CHAMBER_TEMPTABLE_LEN);
|
2018-05-11 06:01:51 +00:00
|
|
|
#elif ENABLED(HEATER_CHAMBER_USES_AD595)
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif ENABLED(HEATER_CHAMBER_USES_AD8495)
|
|
|
|
return TEMP_AD8495(raw);
|
2018-02-24 06:38:58 +00:00
|
|
|
#else
|
2020-01-17 23:16:45 +00:00
|
|
|
UNUSED(raw);
|
2018-05-11 06:01:51 +00:00
|
|
|
return 0;
|
2018-02-24 06:38:58 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif // HAS_TEMP_CHAMBER
|
|
|
|
|
2020-01-17 23:16:45 +00:00
|
|
|
#if HAS_TEMP_PROBE
|
|
|
|
// Derived from RepRap FiveD extruder::getTemperature()
|
|
|
|
// For probe temperature measurement.
|
|
|
|
float Temperature::analog_to_celsius_probe(const int raw) {
|
|
|
|
#if ENABLED(PROBE_USER_THERMISTOR)
|
|
|
|
return user_thermistor_to_deg_c(CTI_PROBE, raw);
|
|
|
|
#elif ENABLED(PROBE_USES_THERMISTOR)
|
|
|
|
SCAN_THERMISTOR_TABLE(PROBE_TEMPTABLE, PROBE_TEMPTABLE_LEN);
|
|
|
|
#elif ENABLED(PROBE_USES_AD595)
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif ENABLED(PROBE_USES_AD8495)
|
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
UNUSED(raw);
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif // HAS_TEMP_PROBE
|
|
|
|
|
2016-04-29 01:18:13 +00:00
|
|
|
/**
|
|
|
|
* Get the raw values into the actual temperatures.
|
|
|
|
* The raw values are created in interrupt context,
|
|
|
|
* and this function is called from normal context
|
|
|
|
* as it would block the stepper routine.
|
|
|
|
*/
|
|
|
|
void Temperature::updateTemperaturesFromRawValues() {
|
2015-07-31 05:29:30 +00:00
|
|
|
#if ENABLED(HEATER_0_USES_MAX6675)
|
2019-03-07 08:09:39 +00:00
|
|
|
temp_hotend[0].raw = READ_MAX6675(0);
|
2018-11-17 00:20:33 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(HEATER_1_USES_MAX6675)
|
2019-03-07 08:09:39 +00:00
|
|
|
temp_hotend[1].raw = READ_MAX6675(1);
|
2015-02-26 08:33:30 +00:00
|
|
|
#endif
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-09-10 07:20:49 +00:00
|
|
|
HOTEND_LOOP() temp_hotend[e].celsius = analog_to_celsius_hotend(temp_hotend[e].raw, e);
|
|
|
|
#endif
|
2020-06-18 20:23:03 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HAS_HEATED_BED, temp_bed.celsius = analog_to_celsius_bed(temp_bed.raw));
|
|
|
|
TERN_(HAS_TEMP_CHAMBER, temp_chamber.celsius = analog_to_celsius_chamber(temp_chamber.raw));
|
|
|
|
TERN_(HAS_TEMP_PROBE, temp_probe.celsius = analog_to_celsius_probe(temp_probe.raw));
|
|
|
|
TERN_(TEMP_SENSOR_1_AS_REDUNDANT, redundant_temperature = analog_to_celsius_hotend(redundant_temperature_raw, 1));
|
|
|
|
TERN_(FILAMENT_WIDTH_SENSOR, filwidth.update_measured_mm());
|
2020-06-18 20:23:03 +00:00
|
|
|
TERN_(HAS_POWER_MONITOR, power_monitor.capture_values());
|
2015-10-13 10:57:36 +00:00
|
|
|
|
2019-09-29 22:57:29 +00:00
|
|
|
// Reset the watchdog on good temperature measurement
|
|
|
|
watchdog_refresh();
|
2015-02-26 08:33:30 +00:00
|
|
|
|
2020-01-26 23:39:45 +00:00
|
|
|
raw_temps_ready = false;
|
2012-12-09 22:00:06 +00:00
|
|
|
}
|
|
|
|
|
2019-02-06 04:56:13 +00:00
|
|
|
#if MAX6675_SEPARATE_SPI
|
2017-09-16 01:47:04 +00:00
|
|
|
SPIclass<MAX6675_DO_PIN, MOSI_PIN, MAX6675_SCK_PIN> max6675_spi;
|
2017-01-08 16:08:50 +00:00
|
|
|
#endif
|
2014-08-07 00:30:57 +00:00
|
|
|
|
2019-03-13 11:51:15 +00:00
|
|
|
// Init fans according to whether they're native PWM or Software PWM
|
2019-07-14 23:05:24 +00:00
|
|
|
#ifdef ALFAWISE_UX0
|
|
|
|
#define _INIT_SOFT_FAN(P) OUT_WRITE_OD(P, FAN_INVERTING ? LOW : HIGH)
|
|
|
|
#else
|
|
|
|
#define _INIT_SOFT_FAN(P) OUT_WRITE(P, FAN_INVERTING ? LOW : HIGH)
|
|
|
|
#endif
|
2019-03-13 11:51:15 +00:00
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
|
|
|
#define _INIT_FAN_PIN(P) _INIT_SOFT_FAN(P)
|
|
|
|
#else
|
|
|
|
#define _INIT_FAN_PIN(P) do{ if (PWM_PIN(P)) SET_PWM(P); else _INIT_SOFT_FAN(P); }while(0)
|
|
|
|
#endif
|
|
|
|
#if ENABLED(FAST_PWM_FAN)
|
|
|
|
#define SET_FAST_PWM_FREQ(P) set_pwm_frequency(P, FAST_PWM_FAN_FREQUENCY)
|
|
|
|
#else
|
|
|
|
#define SET_FAST_PWM_FREQ(P) NOOP
|
|
|
|
#endif
|
|
|
|
#define INIT_FAN_PIN(P) do{ _INIT_FAN_PIN(P); SET_FAST_PWM_FREQ(P); }while(0)
|
|
|
|
#if EXTRUDER_AUTO_FAN_SPEED != 255
|
2019-05-05 03:51:47 +00:00
|
|
|
#define INIT_E_AUTO_FAN_PIN(P) do{ if (P == FAN1_PIN || P == FAN2_PIN) { SET_PWM(P); SET_FAST_PWM_FREQ(FAST_PWM_FAN_FREQUENCY); } else SET_OUTPUT(P); }while(0)
|
|
|
|
#else
|
|
|
|
#define INIT_E_AUTO_FAN_PIN(P) SET_OUTPUT(P)
|
|
|
|
#endif
|
|
|
|
#if CHAMBER_AUTO_FAN_SPEED != 255
|
|
|
|
#define INIT_CHAMBER_AUTO_FAN_PIN(P) do{ if (P == FAN1_PIN || P == FAN2_PIN) { SET_PWM(P); SET_FAST_PWM_FREQ(FAST_PWM_FAN_FREQUENCY); } else SET_OUTPUT(P); }while(0)
|
2019-03-13 11:51:15 +00:00
|
|
|
#else
|
2019-05-05 03:51:47 +00:00
|
|
|
#define INIT_CHAMBER_AUTO_FAN_PIN(P) SET_OUTPUT(P)
|
2019-03-13 11:51:15 +00:00
|
|
|
#endif
|
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
/**
|
|
|
|
* Initialize the temperature manager
|
|
|
|
* The manager is implemented by periodic calls to manage_heater()
|
|
|
|
*/
|
2016-04-29 01:18:13 +00:00
|
|
|
void Temperature::init() {
|
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(MAX6675_IS_MAX31865, max31865.begin(MAX31865_2WIRE)); // MAX31865_2WIRE, MAX31865_3WIRE, MAX31865_4WIRE
|
2019-11-21 09:15:10 +00:00
|
|
|
|
2018-03-22 00:04:45 +00:00
|
|
|
#if EARLY_WATCHDOG
|
|
|
|
// Flag that the thermalManager should be running
|
|
|
|
if (inited) return;
|
|
|
|
inited = true;
|
|
|
|
#endif
|
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
#if MB(RUMBA)
|
2020-02-27 13:47:40 +00:00
|
|
|
// Disable RUMBA JTAG in case the thermocouple extension is plugged on top of JTAG connector
|
2020-01-25 08:13:39 +00:00
|
|
|
#define _AD(N) ANY(HEATER_##N##_USES_AD595, HEATER_##N##_USES_AD8495)
|
2020-07-06 22:08:52 +00:00
|
|
|
#if _AD(0) || _AD(1) || _AD(2) || _AD(BED) || _AD(CHAMBER)
|
2019-03-07 08:09:39 +00:00
|
|
|
MCUCR = _BV(JTD);
|
|
|
|
MCUCR = _BV(JTD);
|
|
|
|
#endif
|
2015-02-24 12:46:11 +00:00
|
|
|
#endif
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2020-07-06 22:08:52 +00:00
|
|
|
// Thermistor activation by MCU pin
|
|
|
|
#if PIN_EXISTS(TEMP_0_TR_ENABLE_PIN)
|
|
|
|
OUT_WRITE(TEMP_0_TR_ENABLE_PIN, ENABLED(HEATER_0_USES_MAX6675));
|
|
|
|
#endif
|
|
|
|
#if PIN_EXISTS(TEMP_1_TR_ENABLE_PIN)
|
|
|
|
OUT_WRITE(TEMP_1_TR_ENABLE_PIN, ENABLED(HEATER_1_USES_MAX6675));
|
|
|
|
#endif
|
|
|
|
|
2019-03-17 04:43:06 +00:00
|
|
|
#if BOTH(PIDTEMP, PID_EXTRUSION_SCALING)
|
2016-07-12 05:06:44 +00:00
|
|
|
last_e_position = 0;
|
|
|
|
#endif
|
|
|
|
|
2015-02-26 08:33:30 +00:00
|
|
|
#if HAS_HEATER_0
|
2019-07-14 23:05:24 +00:00
|
|
|
#ifdef ALFAWISE_UX0
|
|
|
|
OUT_WRITE_OD(HEATER_0_PIN, HEATER_0_INVERTING);
|
|
|
|
#else
|
|
|
|
OUT_WRITE(HEATER_0_PIN, HEATER_0_INVERTING);
|
|
|
|
#endif
|
2015-01-23 22:13:06 +00:00
|
|
|
#endif
|
2019-07-14 23:05:24 +00:00
|
|
|
|
2015-02-26 08:33:30 +00:00
|
|
|
#if HAS_HEATER_1
|
2018-04-03 00:37:41 +00:00
|
|
|
OUT_WRITE(HEATER_1_PIN, HEATER_1_INVERTING);
|
2015-01-23 18:37:39 +00:00
|
|
|
#endif
|
2015-02-26 08:33:30 +00:00
|
|
|
#if HAS_HEATER_2
|
2018-04-03 00:37:41 +00:00
|
|
|
OUT_WRITE(HEATER_2_PIN, HEATER_2_INVERTING);
|
2015-01-23 22:13:06 +00:00
|
|
|
#endif
|
2015-02-26 08:33:30 +00:00
|
|
|
#if HAS_HEATER_3
|
2018-04-03 00:37:41 +00:00
|
|
|
OUT_WRITE(HEATER_3_PIN, HEATER_3_INVERTING);
|
2015-01-23 22:13:06 +00:00
|
|
|
#endif
|
2017-04-06 21:46:52 +00:00
|
|
|
#if HAS_HEATER_4
|
2019-01-12 04:54:15 +00:00
|
|
|
OUT_WRITE(HEATER_4_PIN, HEATER_4_INVERTING);
|
2017-04-06 21:46:52 +00:00
|
|
|
#endif
|
2019-03-07 08:09:39 +00:00
|
|
|
#if HAS_HEATER_5
|
|
|
|
OUT_WRITE(HEATER_5_PIN, HEATER_5_INVERTING);
|
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
#if HAS_HEATER_6
|
|
|
|
OUT_WRITE(HEATER_6_PIN, HEATER_6_INVERTING);
|
|
|
|
#endif
|
|
|
|
#if HAS_HEATER_7
|
|
|
|
OUT_WRITE(HEATER_7_PIN, HEATER_7_INVERTING);
|
|
|
|
#endif
|
2019-07-14 23:05:24 +00:00
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2019-07-14 23:05:24 +00:00
|
|
|
#ifdef ALFAWISE_UX0
|
|
|
|
OUT_WRITE_OD(HEATER_BED_PIN, HEATER_BED_INVERTING);
|
|
|
|
#else
|
|
|
|
OUT_WRITE(HEATER_BED_PIN, HEATER_BED_INVERTING);
|
|
|
|
#endif
|
2015-10-03 06:08:58 +00:00
|
|
|
#endif
|
2019-07-14 23:05:24 +00:00
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
#if HAS_HEATED_CHAMBER
|
|
|
|
OUT_WRITE(HEATER_CHAMBER_PIN, HEATER_CHAMBER_INVERTING);
|
|
|
|
#endif
|
2019-03-13 11:51:15 +00:00
|
|
|
|
2016-08-14 03:16:13 +00:00
|
|
|
#if HAS_FAN0
|
2019-03-13 11:51:15 +00:00
|
|
|
INIT_FAN_PIN(FAN_PIN);
|
2016-08-14 03:16:13 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_FAN1
|
2019-03-13 11:51:15 +00:00
|
|
|
INIT_FAN_PIN(FAN1_PIN);
|
2016-08-14 03:16:13 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_FAN2
|
2019-03-13 11:51:15 +00:00
|
|
|
INIT_FAN_PIN(FAN2_PIN);
|
2016-08-14 03:16:13 +00:00
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
#if HAS_FAN3
|
|
|
|
INIT_FAN_PIN(FAN3_PIN);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN4
|
|
|
|
INIT_FAN_PIN(FAN4_PIN);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN5
|
|
|
|
INIT_FAN_PIN(FAN5_PIN);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN6
|
|
|
|
INIT_FAN_PIN(FAN6_PIN);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN7
|
|
|
|
INIT_FAN_PIN(FAN7_PIN);
|
|
|
|
#endif
|
2018-11-23 22:03:39 +00:00
|
|
|
#if ENABLED(USE_CONTROLLER_FAN)
|
2019-03-13 11:51:15 +00:00
|
|
|
INIT_FAN_PIN(CONTROLLER_FAN_PIN);
|
2018-11-23 22:03:39 +00:00
|
|
|
#endif
|
|
|
|
|
2019-02-06 04:56:13 +00:00
|
|
|
#if MAX6675_SEPARATE_SPI
|
2015-01-23 18:37:39 +00:00
|
|
|
|
2016-10-13 07:03:20 +00:00
|
|
|
OUT_WRITE(SCK_PIN, LOW);
|
|
|
|
OUT_WRITE(MOSI_PIN, HIGH);
|
2017-03-08 05:43:33 +00:00
|
|
|
SET_INPUT_PULLUP(MISO_PIN);
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2017-01-08 16:08:50 +00:00
|
|
|
max6675_spi.init();
|
|
|
|
|
|
|
|
OUT_WRITE(SS_PIN, HIGH);
|
2018-11-17 00:20:33 +00:00
|
|
|
OUT_WRITE(MAX6675_SS_PIN, HIGH);
|
2015-01-23 18:37:39 +00:00
|
|
|
|
2019-02-06 04:56:13 +00:00
|
|
|
#endif
|
2012-02-05 12:05:07 +00:00
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
#if ENABLED(HEATER_1_USES_MAX6675)
|
|
|
|
OUT_WRITE(MAX6675_SS2_PIN, HIGH);
|
|
|
|
#endif
|
|
|
|
|
2017-06-17 23:36:10 +00:00
|
|
|
HAL_adc_init();
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_0
|
2017-06-17 23:36:10 +00:00
|
|
|
HAL_ANALOG_SELECT(TEMP_0_PIN);
|
2011-11-20 12:14:58 +00:00
|
|
|
#endif
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_1
|
2017-06-17 23:36:10 +00:00
|
|
|
HAL_ANALOG_SELECT(TEMP_1_PIN);
|
2011-11-20 12:14:58 +00:00
|
|
|
#endif
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_2
|
2017-06-17 23:36:10 +00:00
|
|
|
HAL_ANALOG_SELECT(TEMP_2_PIN);
|
2015-01-23 22:13:06 +00:00
|
|
|
#endif
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_3
|
2017-06-17 23:36:10 +00:00
|
|
|
HAL_ANALOG_SELECT(TEMP_3_PIN);
|
2011-11-20 12:14:58 +00:00
|
|
|
#endif
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_4
|
2017-06-17 23:36:10 +00:00
|
|
|
HAL_ANALOG_SELECT(TEMP_4_PIN);
|
2017-04-06 21:46:52 +00:00
|
|
|
#endif
|
2018-09-13 06:35:55 +00:00
|
|
|
#if HAS_TEMP_ADC_5
|
|
|
|
HAL_ANALOG_SELECT(TEMP_5_PIN);
|
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
#if HAS_TEMP_ADC_6
|
|
|
|
HAL_ANALOG_SELECT(TEMP_6_PIN);
|
|
|
|
#endif
|
|
|
|
#if HAS_TEMP_ADC_7
|
|
|
|
HAL_ANALOG_SELECT(TEMP_7_PIN);
|
|
|
|
#endif
|
2019-09-08 05:55:34 +00:00
|
|
|
#if HAS_JOY_ADC_X
|
|
|
|
HAL_ANALOG_SELECT(JOY_X_PIN);
|
|
|
|
#endif
|
|
|
|
#if HAS_JOY_ADC_Y
|
|
|
|
HAL_ANALOG_SELECT(JOY_Y_PIN);
|
|
|
|
#endif
|
|
|
|
#if HAS_JOY_ADC_Z
|
|
|
|
HAL_ANALOG_SELECT(JOY_Z_PIN);
|
|
|
|
#endif
|
|
|
|
#if HAS_JOY_ADC_EN
|
|
|
|
SET_INPUT_PULLUP(JOY_EN_PIN);
|
|
|
|
#endif
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2017-06-17 23:36:10 +00:00
|
|
|
HAL_ANALOG_SELECT(TEMP_BED_PIN);
|
2011-12-06 04:33:33 +00:00
|
|
|
#endif
|
2018-02-24 06:38:58 +00:00
|
|
|
#if HAS_TEMP_CHAMBER
|
|
|
|
HAL_ANALOG_SELECT(TEMP_CHAMBER_PIN);
|
|
|
|
#endif
|
2020-01-17 23:16:45 +00:00
|
|
|
#if HAS_TEMP_PROBE
|
|
|
|
HAL_ANALOG_SELECT(TEMP_PROBE_PIN);
|
|
|
|
#endif
|
2016-03-30 03:28:23 +00:00
|
|
|
#if ENABLED(FILAMENT_WIDTH_SENSOR)
|
2017-06-17 23:36:10 +00:00
|
|
|
HAL_ANALOG_SELECT(FILWIDTH_PIN);
|
|
|
|
#endif
|
2019-07-11 18:47:41 +00:00
|
|
|
#if HAS_ADC_BUTTONS
|
|
|
|
HAL_ANALOG_SELECT(ADC_KEYPAD_PIN);
|
|
|
|
#endif
|
2020-06-18 20:23:03 +00:00
|
|
|
#if ENABLED(POWER_MONITOR_CURRENT)
|
|
|
|
HAL_ANALOG_SELECT(POWER_MONITOR_CURRENT_PIN);
|
|
|
|
#endif
|
|
|
|
#if ENABLED(POWER_MONITOR_VOLTAGE)
|
|
|
|
HAL_ANALOG_SELECT(POWER_MONITOR_VOLTAGE_PIN);
|
|
|
|
#endif
|
2017-06-17 23:36:10 +00:00
|
|
|
|
2018-06-03 06:43:00 +00:00
|
|
|
HAL_timer_start(TEMP_TIMER_NUM, TEMP_TIMER_FREQUENCY);
|
2018-04-24 03:05:07 +00:00
|
|
|
ENABLE_TEMPERATURE_INTERRUPT();
|
2015-06-10 00:01:47 +00:00
|
|
|
|
2015-06-09 23:54:28 +00:00
|
|
|
#if HAS_AUTO_FAN_0
|
2019-05-05 03:51:47 +00:00
|
|
|
INIT_E_AUTO_FAN_PIN(E0_AUTO_FAN_PIN);
|
2015-06-09 23:54:28 +00:00
|
|
|
#endif
|
2019-10-10 00:46:10 +00:00
|
|
|
#if HAS_AUTO_FAN_1 && !_EFANOVERLAP(1,0)
|
2019-05-05 03:51:47 +00:00
|
|
|
INIT_E_AUTO_FAN_PIN(E1_AUTO_FAN_PIN);
|
2015-06-09 23:54:28 +00:00
|
|
|
#endif
|
2019-10-10 00:46:10 +00:00
|
|
|
#if HAS_AUTO_FAN_2 && !(_EFANOVERLAP(2,0) || _EFANOVERLAP(2,1))
|
2019-05-05 03:51:47 +00:00
|
|
|
INIT_E_AUTO_FAN_PIN(E2_AUTO_FAN_PIN);
|
2015-06-09 23:54:28 +00:00
|
|
|
#endif
|
2019-10-10 00:46:10 +00:00
|
|
|
#if HAS_AUTO_FAN_3 && !(_EFANOVERLAP(3,0) || _EFANOVERLAP(3,1) || _EFANOVERLAP(3,2))
|
2019-05-05 03:51:47 +00:00
|
|
|
INIT_E_AUTO_FAN_PIN(E3_AUTO_FAN_PIN);
|
2015-06-09 23:54:28 +00:00
|
|
|
#endif
|
2019-10-10 00:46:10 +00:00
|
|
|
#if HAS_AUTO_FAN_4 && !(_EFANOVERLAP(4,0) || _EFANOVERLAP(4,1) || _EFANOVERLAP(4,2) || _EFANOVERLAP(4,3))
|
2019-05-05 03:51:47 +00:00
|
|
|
INIT_E_AUTO_FAN_PIN(E4_AUTO_FAN_PIN);
|
2017-04-06 21:46:52 +00:00
|
|
|
#endif
|
2019-10-10 00:46:10 +00:00
|
|
|
#if HAS_AUTO_FAN_5 && !(_EFANOVERLAP(5,0) || _EFANOVERLAP(5,1) || _EFANOVERLAP(5,2) || _EFANOVERLAP(5,3) || _EFANOVERLAP(5,4))
|
2019-05-05 03:51:47 +00:00
|
|
|
INIT_E_AUTO_FAN_PIN(E5_AUTO_FAN_PIN);
|
2018-09-13 06:35:55 +00:00
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
#if HAS_AUTO_FAN_6 && !(_EFANOVERLAP(6,0) || _EFANOVERLAP(6,1) || _EFANOVERLAP(6,2) || _EFANOVERLAP(6,3) || _EFANOVERLAP(6,4) || _EFANOVERLAP(6,5))
|
|
|
|
INIT_E_AUTO_FAN_PIN(E6_AUTO_FAN_PIN);
|
|
|
|
#endif
|
|
|
|
#if HAS_AUTO_FAN_7 && !(_EFANOVERLAP(7,0) || _EFANOVERLAP(7,1) || _EFANOVERLAP(7,2) || _EFANOVERLAP(7,3) || _EFANOVERLAP(7,4) || _EFANOVERLAP(7,5) || _EFANOVERLAP(7,6))
|
|
|
|
INIT_E_AUTO_FAN_PIN(E7_AUTO_FAN_PIN);
|
|
|
|
#endif
|
2019-05-05 03:51:47 +00:00
|
|
|
#if HAS_AUTO_CHAMBER_FAN && !AUTO_CHAMBER_IS_E
|
|
|
|
INIT_CHAMBER_AUTO_FAN_PIN(CHAMBER_AUTO_FAN_PIN);
|
2018-02-24 06:38:58 +00:00
|
|
|
#endif
|
2015-06-09 23:54:28 +00:00
|
|
|
|
2011-11-19 11:19:53 +00:00
|
|
|
// Wait for temperature measurement to settle
|
2011-12-06 04:33:33 +00:00
|
|
|
delay(250);
|
2011-11-19 11:19:53 +00:00
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2015-01-23 22:13:06 +00:00
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
#define _TEMP_MIN_E(NR) do{ \
|
2020-07-08 11:28:32 +00:00
|
|
|
const int16_t tmin = _MAX(HEATER_ ##NR## _MINTEMP, TERN(HEATER_##NR##_USER_THERMISTOR, 0, (int16_t)pgm_read_word(&HEATER_ ##NR## _TEMPTABLE[HEATER_ ##NR## _SENSOR_MINTEMP_IND].celsius))); \
|
2020-07-01 21:27:28 +00:00
|
|
|
temp_range[NR].mintemp = tmin; \
|
|
|
|
while (analog_to_celsius_hotend(temp_range[NR].raw_min, NR) < tmin) \
|
2019-03-07 08:09:39 +00:00
|
|
|
temp_range[NR].raw_min += TEMPDIR(NR) * (OVERSAMPLENR); \
|
|
|
|
}while(0)
|
|
|
|
#define _TEMP_MAX_E(NR) do{ \
|
2020-07-08 11:28:32 +00:00
|
|
|
const int16_t tmax = _MIN(HEATER_ ##NR## _MAXTEMP, TERN(HEATER_##NR##_USER_THERMISTOR, 2000, (int16_t)pgm_read_word(&HEATER_ ##NR## _TEMPTABLE[HEATER_ ##NR## _SENSOR_MAXTEMP_IND].celsius) - 1)); \
|
2020-07-01 21:27:28 +00:00
|
|
|
temp_range[NR].maxtemp = tmax; \
|
|
|
|
while (analog_to_celsius_hotend(temp_range[NR].raw_max, NR) > tmax) \
|
2019-03-07 08:09:39 +00:00
|
|
|
temp_range[NR].raw_max -= TEMPDIR(NR) * (OVERSAMPLENR); \
|
|
|
|
}while(0)
|
|
|
|
|
2020-07-05 01:04:31 +00:00
|
|
|
#define _MINMAX_TEST(N,M) (HOTENDS > N && THERMISTOR_HEATER_##N && THERMISTOR_HEATER_##N != 998 && THERMISTOR_HEATER_##N != 999 && defined(HEATER_##N##_##M##TEMP))
|
2020-07-07 06:50:57 +00:00
|
|
|
|
2020-07-05 01:04:31 +00:00
|
|
|
#if _MINMAX_TEST(0, MIN)
|
2019-03-07 08:09:39 +00:00
|
|
|
_TEMP_MIN_E(0);
|
2015-02-24 12:46:11 +00:00
|
|
|
#endif
|
2020-07-05 01:04:31 +00:00
|
|
|
#if _MINMAX_TEST(0, MAX)
|
2020-07-07 06:50:57 +00:00
|
|
|
_TEMP_MAX_E(0);
|
2020-07-01 21:27:28 +00:00
|
|
|
#endif
|
2020-07-05 01:04:31 +00:00
|
|
|
#if _MINMAX_TEST(1, MIN)
|
|
|
|
_TEMP_MIN_E(1);
|
2020-07-01 21:27:28 +00:00
|
|
|
#endif
|
2020-07-05 01:04:31 +00:00
|
|
|
#if _MINMAX_TEST(1, MAX)
|
|
|
|
_TEMP_MAX_E(1);
|
2020-07-01 21:27:28 +00:00
|
|
|
#endif
|
2020-07-05 01:04:31 +00:00
|
|
|
#if _MINMAX_TEST(2, MIN)
|
|
|
|
_TEMP_MIN_E(2);
|
2020-07-01 21:27:28 +00:00
|
|
|
#endif
|
2020-07-05 01:04:31 +00:00
|
|
|
#if _MINMAX_TEST(2, MAX)
|
|
|
|
_TEMP_MAX_E(2);
|
2020-07-01 21:27:28 +00:00
|
|
|
#endif
|
2020-07-05 01:04:31 +00:00
|
|
|
#if _MINMAX_TEST(3, MIN)
|
|
|
|
_TEMP_MIN_E(3);
|
2020-07-01 21:27:28 +00:00
|
|
|
#endif
|
2020-07-05 01:04:31 +00:00
|
|
|
#if _MINMAX_TEST(3, MAX)
|
|
|
|
_TEMP_MAX_E(3);
|
|
|
|
#endif
|
|
|
|
#if _MINMAX_TEST(4, MIN)
|
|
|
|
_TEMP_MIN_E(4);
|
|
|
|
#endif
|
|
|
|
#if _MINMAX_TEST(4, MAX)
|
|
|
|
_TEMP_MAX_E(4);
|
|
|
|
#endif
|
|
|
|
#if _MINMAX_TEST(5, MIN)
|
|
|
|
_TEMP_MIN_E(5);
|
|
|
|
#endif
|
|
|
|
#if _MINMAX_TEST(5, MAX)
|
|
|
|
_TEMP_MAX_E(5);
|
|
|
|
#endif
|
|
|
|
#if _MINMAX_TEST(6, MIN)
|
|
|
|
_TEMP_MIN_E(6);
|
|
|
|
#endif
|
|
|
|
#if _MINMAX_TEST(6, MAX)
|
|
|
|
_TEMP_MAX_E(6);
|
|
|
|
#endif
|
|
|
|
#if _MINMAX_TEST(7, MIN)
|
|
|
|
_TEMP_MIN_E(7);
|
|
|
|
#endif
|
|
|
|
#if _MINMAX_TEST(7, MAX)
|
|
|
|
_TEMP_MAX_E(7);
|
2020-07-01 21:27:28 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif // HAS_HOTEND
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2018-01-02 00:24:54 +00:00
|
|
|
#ifdef BED_MINTEMP
|
2019-03-07 08:09:39 +00:00
|
|
|
while (analog_to_celsius_bed(mintemp_raw_BED) < BED_MINTEMP) mintemp_raw_BED += TEMPDIR(BED) * (OVERSAMPLENR);
|
|
|
|
#endif
|
2018-01-02 00:24:54 +00:00
|
|
|
#ifdef BED_MAXTEMP
|
2019-05-06 03:54:49 +00:00
|
|
|
while (analog_to_celsius_bed(maxtemp_raw_BED) > BED_MAXTEMP) maxtemp_raw_BED -= TEMPDIR(BED) * (OVERSAMPLENR);
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif
|
2018-04-23 22:13:01 +00:00
|
|
|
#endif // HAS_HEATED_BED
|
2017-05-07 11:06:06 +00:00
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
#if HAS_HEATED_CHAMBER
|
|
|
|
#ifdef CHAMBER_MINTEMP
|
|
|
|
while (analog_to_celsius_chamber(mintemp_raw_CHAMBER) < CHAMBER_MINTEMP) mintemp_raw_CHAMBER += TEMPDIR(CHAMBER) * (OVERSAMPLENR);
|
|
|
|
#endif
|
|
|
|
#ifdef CHAMBER_MAXTEMP
|
2019-05-06 03:54:49 +00:00
|
|
|
while (analog_to_celsius_chamber(maxtemp_raw_CHAMBER) > CHAMBER_MAXTEMP) maxtemp_raw_CHAMBER -= TEMPDIR(CHAMBER) * (OVERSAMPLENR);
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(PROBING_HEATERS_OFF, paused = false);
|
2011-11-15 21:50:43 +00:00
|
|
|
}
|
|
|
|
|
2017-04-02 16:48:10 +00:00
|
|
|
#if WATCH_HOTENDS
|
2015-05-09 05:36:02 +00:00
|
|
|
/**
|
|
|
|
* Start Heating Sanity Check for hotends that are below
|
|
|
|
* their target temperature by a configurable margin.
|
|
|
|
* This is called when the temperature is set. (M104, M109)
|
|
|
|
*/
|
2019-10-01 02:44:07 +00:00
|
|
|
void Temperature::start_watching_hotend(const uint8_t E_NAME) {
|
2019-07-02 13:39:55 +00:00
|
|
|
const uint8_t ee = HOTEND_INDEX;
|
2020-01-30 09:24:43 +00:00
|
|
|
watch_hotend[ee].restart(degHotend(ee), degTargetHotend(ee));
|
2015-05-09 05:36:02 +00:00
|
|
|
}
|
|
|
|
#endif
|
2011-11-15 21:50:43 +00:00
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
#if WATCH_BED
|
2016-04-15 16:27:18 +00:00
|
|
|
/**
|
|
|
|
* Start Heating Sanity Check for hotends that are below
|
|
|
|
* their target temperature by a configurable margin.
|
|
|
|
* This is called when the temperature is set. (M140, M190)
|
|
|
|
*/
|
2016-04-29 01:18:13 +00:00
|
|
|
void Temperature::start_watching_bed() {
|
2020-01-30 09:24:43 +00:00
|
|
|
watch_bed.restart(degBed(), degTargetBed());
|
2016-04-15 16:27:18 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
#if WATCH_CHAMBER
|
|
|
|
/**
|
2019-05-07 00:55:01 +00:00
|
|
|
* Start Heating Sanity Check for chamber that is below
|
|
|
|
* its target temperature by a configurable margin.
|
2019-03-07 08:09:39 +00:00
|
|
|
* This is called when the temperature is set. (M141, M191)
|
|
|
|
*/
|
|
|
|
void Temperature::start_watching_chamber() {
|
2020-01-30 09:24:43 +00:00
|
|
|
watch_chamber.restart(degChamber(), degTargetChamber());
|
2019-03-07 08:09:39 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-04-22 01:50:32 +00:00
|
|
|
#if HAS_THERMAL_PROTECTION
|
2015-04-02 12:10:14 +00:00
|
|
|
|
2016-05-26 18:58:38 +00:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS)
|
2019-03-07 08:09:39 +00:00
|
|
|
Temperature::tr_state_machine_t Temperature::tr_state_machine[HOTENDS]; // = { { TRInactive, 0 } };
|
2016-05-26 18:58:38 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_THERMALLY_PROTECTED_BED
|
2019-03-07 08:09:39 +00:00
|
|
|
Temperature::tr_state_machine_t Temperature::tr_state_machine_bed; // = { TRInactive, 0 };
|
|
|
|
#endif
|
|
|
|
#if ENABLED(THERMAL_PROTECTION_CHAMBER)
|
|
|
|
Temperature::tr_state_machine_t Temperature::tr_state_machine_chamber; // = { TRInactive, 0 };
|
2016-05-26 18:58:38 +00:00
|
|
|
#endif
|
|
|
|
|
2020-09-13 23:06:14 +00:00
|
|
|
void Temperature::thermal_runaway_protection(Temperature::tr_state_machine_t &sm, const float ¤t, const float &target, const heater_id_t heater_id, const uint16_t period_seconds, const uint16_t hysteresis_degc) {
|
2015-04-04 02:34:55 +00:00
|
|
|
|
2016-05-27 00:43:20 +00:00
|
|
|
static float tr_target_temperature[HOTENDS + 1] = { 0.0 };
|
2015-04-04 02:34:55 +00:00
|
|
|
|
2016-03-25 06:19:46 +00:00
|
|
|
/**
|
2019-04-22 01:50:32 +00:00
|
|
|
SERIAL_ECHO_START();
|
2020-03-14 23:47:44 +00:00
|
|
|
SERIAL_ECHOPGM("Thermal Runaway Running. Heater ID: ");
|
2019-07-02 13:39:55 +00:00
|
|
|
if (heater_id == H_CHAMBER) SERIAL_ECHOPGM("chamber");
|
2019-04-22 01:50:32 +00:00
|
|
|
if (heater_id < 0) SERIAL_ECHOPGM("bed"); else SERIAL_ECHO(heater_id);
|
|
|
|
SERIAL_ECHOPAIR(" ; State:", sm.state, " ; Timer:", sm.timer, " ; Temperature:", current, " ; Target Temp:", target);
|
|
|
|
if (heater_id >= 0)
|
|
|
|
SERIAL_ECHOPAIR(" ; Idle Timeout:", hotend_idle[heater_id].timed_out);
|
|
|
|
else
|
|
|
|
SERIAL_ECHOPAIR(" ; Idle Timeout:", bed_idle.timed_out);
|
|
|
|
SERIAL_EOL();
|
|
|
|
//*/
|
2015-04-04 12:45:36 +00:00
|
|
|
|
2017-06-15 20:14:08 +00:00
|
|
|
const int heater_index = heater_id >= 0 ? heater_id : HOTENDS;
|
2015-04-04 13:18:08 +00:00
|
|
|
|
2017-06-12 05:22:31 +00:00
|
|
|
#if HEATER_IDLE_HANDLER
|
2017-05-26 18:01:02 +00:00
|
|
|
// If the heater idle timeout expires, restart
|
2019-03-07 08:09:39 +00:00
|
|
|
if ((heater_id >= 0 && hotend_idle[heater_id].timed_out)
|
2020-04-22 21:35:03 +00:00
|
|
|
|| TERN0(HAS_HEATED_BED, (heater_id < 0 && bed_idle.timed_out))
|
2018-01-02 00:24:54 +00:00
|
|
|
) {
|
2019-03-07 08:09:39 +00:00
|
|
|
sm.state = TRInactive;
|
2017-05-26 18:01:02 +00:00
|
|
|
tr_target_temperature[heater_index] = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
2018-01-02 00:24:54 +00:00
|
|
|
{
|
|
|
|
// If the target temperature changes, restart
|
|
|
|
if (tr_target_temperature[heater_index] != target) {
|
|
|
|
tr_target_temperature[heater_index] = target;
|
2019-03-07 08:09:39 +00:00
|
|
|
sm.state = target > 0 ? TRFirstHeating : TRInactive;
|
2018-01-02 00:24:54 +00:00
|
|
|
}
|
2016-05-09 00:07:45 +00:00
|
|
|
}
|
2015-04-02 12:10:14 +00:00
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
switch (sm.state) {
|
2015-04-02 13:11:03 +00:00
|
|
|
// Inactive state waits for a target temperature to be set
|
2016-05-09 00:07:45 +00:00
|
|
|
case TRInactive: break;
|
2019-01-12 06:41:48 +00:00
|
|
|
|
2015-04-02 12:10:14 +00:00
|
|
|
// When first heating, wait for the temperature to be reached then go to Stable state
|
|
|
|
case TRFirstHeating:
|
2017-05-03 22:12:14 +00:00
|
|
|
if (current < tr_target_temperature[heater_index]) break;
|
2019-03-07 08:09:39 +00:00
|
|
|
sm.state = TRStable;
|
2019-01-12 06:41:48 +00:00
|
|
|
|
2015-04-02 12:10:14 +00:00
|
|
|
// While the temperature is stable watch for a bad temperature
|
|
|
|
case TRStable:
|
2019-01-12 06:41:48 +00:00
|
|
|
|
2019-02-04 06:12:41 +00:00
|
|
|
#if ENABLED(ADAPTIVE_FAN_SLOWING)
|
|
|
|
if (adaptive_fan_slowing && heater_id >= 0) {
|
2019-07-05 23:01:21 +00:00
|
|
|
const int fan_index = _MIN(heater_id, FAN_COUNT - 1);
|
2019-01-12 06:41:48 +00:00
|
|
|
if (fan_speed[fan_index] == 0 || current >= tr_target_temperature[heater_id] - (hysteresis_degc * 0.25f))
|
|
|
|
fan_speed_scaler[fan_index] = 128;
|
|
|
|
else if (current >= tr_target_temperature[heater_id] - (hysteresis_degc * 0.3335f))
|
|
|
|
fan_speed_scaler[fan_index] = 96;
|
|
|
|
else if (current >= tr_target_temperature[heater_id] - (hysteresis_degc * 0.5f))
|
|
|
|
fan_speed_scaler[fan_index] = 64;
|
|
|
|
else if (current >= tr_target_temperature[heater_id] - (hysteresis_degc * 0.8f))
|
|
|
|
fan_speed_scaler[fan_index] = 32;
|
|
|
|
else
|
|
|
|
fan_speed_scaler[fan_index] = 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2017-05-03 22:12:14 +00:00
|
|
|
if (current >= tr_target_temperature[heater_index] - hysteresis_degc) {
|
2020-04-04 00:49:45 +00:00
|
|
|
sm.timer = millis() + SEC_TO_MS(period_seconds);
|
2016-05-08 23:51:33 +00:00
|
|
|
break;
|
|
|
|
}
|
2019-03-07 08:09:39 +00:00
|
|
|
else if (PENDING(millis(), sm.timer)) break;
|
|
|
|
sm.state = TRRunaway;
|
2019-01-12 06:41:48 +00:00
|
|
|
|
2015-04-04 12:45:36 +00:00
|
|
|
case TRRunaway:
|
2020-06-16 06:45:27 +00:00
|
|
|
TERN_(DWIN_CREALITY_LCD, Popup_Window_Temperature(0));
|
2020-02-26 09:02:03 +00:00
|
|
|
_temp_error(heater_id, str_t_thermal_runaway, GET_TEXT(MSG_THERMAL_RUNAWAY));
|
2015-04-02 12:10:14 +00:00
|
|
|
}
|
2014-06-30 18:22:37 +00:00
|
|
|
}
|
2011-11-15 21:50:43 +00:00
|
|
|
|
2019-07-14 13:56:29 +00:00
|
|
|
#endif // HAS_THERMAL_PROTECTION
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2016-04-29 01:18:13 +00:00
|
|
|
void Temperature::disable_all_heaters() {
|
2017-05-04 01:43:00 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(AUTOTEMP, planner.autotemp_enabled = false);
|
2017-05-04 01:43:00 +00:00
|
|
|
|
2017-05-07 11:06:06 +00:00
|
|
|
// Unpause and reset everything
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(PROBING_HEATERS_OFF, pause(false));
|
2017-05-07 11:06:06 +00:00
|
|
|
|
2020-07-15 06:14:03 +00:00
|
|
|
#if HAS_HOTEND
|
|
|
|
HOTEND_LOOP() {
|
|
|
|
setTargetHotend(0, e);
|
|
|
|
temp_hotend[e].soft_pwm_amount = 0;
|
|
|
|
}
|
|
|
|
#endif
|
2015-03-23 22:18:22 +00:00
|
|
|
|
2016-04-03 23:18:49 +00:00
|
|
|
#if HAS_TEMP_HOTEND
|
2020-07-15 06:20:52 +00:00
|
|
|
#define DISABLE_HEATER(N) WRITE_HEATER_##N(LOW);
|
2019-11-09 23:59:04 +00:00
|
|
|
REPEAT(HOTENDS, DISABLE_HEATER);
|
2015-02-24 12:46:11 +00:00
|
|
|
#endif
|
2015-01-23 22:13:06 +00:00
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2020-07-15 06:14:03 +00:00
|
|
|
setTargetBed(0);
|
2019-03-07 08:09:39 +00:00
|
|
|
temp_bed.soft_pwm_amount = 0;
|
2019-06-28 23:54:22 +00:00
|
|
|
WRITE_HEATER_BED(LOW);
|
2015-02-24 12:46:11 +00:00
|
|
|
#endif
|
2019-03-07 08:09:39 +00:00
|
|
|
|
2019-03-10 14:51:13 +00:00
|
|
|
#if HAS_HEATED_CHAMBER
|
2020-07-15 06:14:03 +00:00
|
|
|
setTargetChamber(0);
|
2019-03-07 08:09:39 +00:00
|
|
|
temp_chamber.soft_pwm_amount = 0;
|
2019-06-28 23:54:22 +00:00
|
|
|
WRITE_HEATER_CHAMBER(LOW);
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif
|
2011-11-15 21:50:43 +00:00
|
|
|
}
|
|
|
|
|
2020-01-30 09:24:43 +00:00
|
|
|
#if ENABLED(PRINTJOB_TIMER_AUTOSTART)
|
|
|
|
|
|
|
|
bool Temperature::over_autostart_threshold() {
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2020-02-01 10:51:57 +00:00
|
|
|
HOTEND_LOOP() if (degTargetHotend(e) > (EXTRUDE_MINTEMP) / 2) return true;
|
2020-01-30 09:24:43 +00:00
|
|
|
#endif
|
2020-04-22 21:35:03 +00:00
|
|
|
return TERN0(HAS_HEATED_BED, degTargetBed() > BED_MINTEMP)
|
|
|
|
|| TERN0(HAS_HEATED_CHAMBER, degTargetChamber() > CHAMBER_MINTEMP);
|
2020-01-30 09:24:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Temperature::check_timer_autostart(const bool can_start, const bool can_stop) {
|
|
|
|
if (over_autostart_threshold()) {
|
|
|
|
if (can_start) startOrResumeJob();
|
|
|
|
}
|
|
|
|
else if (can_stop) {
|
|
|
|
print_job_timer.stop();
|
|
|
|
ui.reset_status();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2017-05-07 11:06:06 +00:00
|
|
|
#if ENABLED(PROBING_HEATERS_OFF)
|
|
|
|
|
2017-05-08 19:09:37 +00:00
|
|
|
void Temperature::pause(const bool p) {
|
|
|
|
if (p != paused) {
|
|
|
|
paused = p;
|
|
|
|
if (p) {
|
2020-04-22 21:35:03 +00:00
|
|
|
HOTEND_LOOP() hotend_idle[e].expire(); // Timeout immediately
|
|
|
|
TERN_(HAS_HEATED_BED, bed_idle.expire()); // Timeout immediately
|
2017-05-08 19:09:37 +00:00
|
|
|
}
|
|
|
|
else {
|
2020-01-30 09:24:43 +00:00
|
|
|
HOTEND_LOOP() reset_hotend_idle_timer(e);
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HAS_HEATED_BED, reset_bed_idle_timer());
|
2017-05-07 11:06:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-08 11:40:50 +00:00
|
|
|
#endif // PROBING_HEATERS_OFF
|
2017-05-07 11:06:06 +00:00
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
#if HAS_MAX6675
|
2016-03-08 14:58:11 +00:00
|
|
|
|
2020-05-20 20:38:29 +00:00
|
|
|
#ifndef THERMOCOUPLE_MAX_ERRORS
|
|
|
|
#define THERMOCOUPLE_MAX_ERRORS 15
|
|
|
|
#endif
|
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
int Temperature::read_max6675(
|
|
|
|
#if COUNT_6675 > 1
|
|
|
|
const uint8_t hindex
|
|
|
|
#endif
|
|
|
|
) {
|
|
|
|
#if COUNT_6675 == 1
|
|
|
|
constexpr uint8_t hindex = 0;
|
2019-01-14 20:29:55 +00:00
|
|
|
#else
|
|
|
|
// Needed to return the correct temp when this is called too soon
|
|
|
|
static uint16_t max6675_temp_previous[COUNT_6675] = { 0 };
|
2018-11-17 00:20:33 +00:00
|
|
|
#endif
|
2020-05-22 07:02:03 +00:00
|
|
|
|
2020-05-20 20:38:29 +00:00
|
|
|
static uint8_t max6675_errors[COUNT_6675] = { 0 };
|
2016-03-08 14:58:11 +00:00
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
#define MAX6675_HEAT_INTERVAL 250UL
|
2012-02-05 12:05:07 +00:00
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
#if ENABLED(MAX6675_IS_MAX31855)
|
|
|
|
static uint32_t max6675_temp = 2000;
|
|
|
|
#define MAX6675_ERROR_MASK 7
|
|
|
|
#define MAX6675_DISCARD_BITS 18
|
|
|
|
#define MAX6675_SPEED_BITS 3 // (_BV(SPR1)) // clock ÷ 64
|
|
|
|
#else
|
|
|
|
static uint16_t max6675_temp = 2000;
|
|
|
|
#define MAX6675_ERROR_MASK 4
|
|
|
|
#define MAX6675_DISCARD_BITS 3
|
|
|
|
#define MAX6675_SPEED_BITS 2 // (_BV(SPR0)) // clock ÷ 16
|
|
|
|
#endif
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
// Return last-read value between readings
|
|
|
|
static millis_t next_max6675_ms[COUNT_6675] = { 0 };
|
2015-04-13 01:07:08 +00:00
|
|
|
millis_t ms = millis();
|
2019-01-14 20:29:55 +00:00
|
|
|
if (PENDING(ms, next_max6675_ms[hindex]))
|
|
|
|
return int(
|
|
|
|
#if COUNT_6675 == 1
|
|
|
|
max6675_temp
|
|
|
|
#else
|
|
|
|
max6675_temp_previous[hindex] // Need to return the correct previous value
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
next_max6675_ms[hindex] = ms + MAX6675_HEAT_INTERVAL;
|
|
|
|
|
2019-11-21 09:15:10 +00:00
|
|
|
#if ENABLED(MAX6675_IS_MAX31865)
|
|
|
|
max6675_temp = int(max31865.temperature(100, 400)); // 100 ohms = PT100 resistance. 400 ohms = calibration resistor
|
|
|
|
#endif
|
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
//
|
|
|
|
// TODO: spiBegin, spiRec and spiInit doesn't work when soft spi is used.
|
|
|
|
//
|
2019-03-31 03:31:50 +00:00
|
|
|
#if !MAX6675_SEPARATE_SPI
|
2018-11-17 00:20:33 +00:00
|
|
|
spiBegin();
|
|
|
|
spiInit(MAX6675_SPEED_BITS);
|
|
|
|
#endif
|
2015-04-13 06:06:50 +00:00
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
#if COUNT_6675 > 1
|
|
|
|
#define WRITE_MAX6675(V) do{ switch (hindex) { case 1: WRITE(MAX6675_SS2_PIN, V); break; default: WRITE(MAX6675_SS_PIN, V); } }while(0)
|
2019-03-31 03:31:50 +00:00
|
|
|
#define SET_OUTPUT_MAX6675() do{ switch (hindex) { case 1: SET_OUTPUT(MAX6675_SS2_PIN); break; default: SET_OUTPUT(MAX6675_SS_PIN); } }while(0)
|
2018-11-17 00:20:33 +00:00
|
|
|
#elif ENABLED(HEATER_1_USES_MAX6675)
|
|
|
|
#define WRITE_MAX6675(V) WRITE(MAX6675_SS2_PIN, V)
|
2019-03-31 03:31:50 +00:00
|
|
|
#define SET_OUTPUT_MAX6675() SET_OUTPUT(MAX6675_SS2_PIN)
|
2018-11-17 00:20:33 +00:00
|
|
|
#else
|
|
|
|
#define WRITE_MAX6675(V) WRITE(MAX6675_SS_PIN, V)
|
2019-03-31 03:31:50 +00:00
|
|
|
#define SET_OUTPUT_MAX6675() SET_OUTPUT(MAX6675_SS_PIN)
|
2018-11-17 00:20:33 +00:00
|
|
|
#endif
|
2015-01-23 18:37:39 +00:00
|
|
|
|
2019-03-31 03:31:50 +00:00
|
|
|
SET_OUTPUT_MAX6675();
|
2018-11-17 00:20:33 +00:00
|
|
|
WRITE_MAX6675(LOW); // enable TT_MAX6675
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2018-05-12 13:34:04 +00:00
|
|
|
DELAY_NS(100); // Ensure 100ns delay
|
2012-02-05 12:05:07 +00:00
|
|
|
|
2016-03-08 14:58:11 +00:00
|
|
|
// Read a big-endian temperature value
|
|
|
|
max6675_temp = 0;
|
2016-04-20 02:57:32 +00:00
|
|
|
for (uint8_t i = sizeof(max6675_temp); i--;) {
|
2018-11-17 00:20:33 +00:00
|
|
|
max6675_temp |= (
|
2019-02-06 04:56:13 +00:00
|
|
|
#if MAX6675_SEPARATE_SPI
|
2018-11-17 00:20:33 +00:00
|
|
|
max6675_spi.receive()
|
|
|
|
#else
|
|
|
|
spiRec()
|
|
|
|
#endif
|
|
|
|
);
|
2016-03-08 14:58:11 +00:00
|
|
|
if (i > 0) max6675_temp <<= 8; // shift left if not the last byte
|
|
|
|
}
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
WRITE_MAX6675(HIGH); // disable TT_MAX6675
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2020-07-11 05:23:48 +00:00
|
|
|
if (DISABLED(IGNORE_THERMOCOUPLE_ERRORS) && (max6675_temp & MAX6675_ERROR_MASK)) {
|
2020-05-20 20:38:29 +00:00
|
|
|
max6675_errors[hindex] += 1;
|
|
|
|
if (max6675_errors[hindex] > THERMOCOUPLE_MAX_ERRORS) {
|
|
|
|
SERIAL_ERROR_START();
|
|
|
|
SERIAL_ECHOPGM("Temp measurement error! ");
|
|
|
|
#if MAX6675_ERROR_MASK == 7
|
|
|
|
SERIAL_ECHOPGM("MAX31855 ");
|
|
|
|
if (max6675_temp & 1)
|
|
|
|
SERIAL_ECHOLNPGM("Open Circuit");
|
|
|
|
else if (max6675_temp & 2)
|
|
|
|
SERIAL_ECHOLNPGM("Short to GND");
|
|
|
|
else if (max6675_temp & 4)
|
|
|
|
SERIAL_ECHOLNPGM("Short to VCC");
|
2018-11-17 00:20:33 +00:00
|
|
|
#else
|
2020-05-20 20:38:29 +00:00
|
|
|
SERIAL_ECHOLNPGM("MAX6675");
|
2018-11-17 00:20:33 +00:00
|
|
|
#endif
|
2020-05-20 20:38:29 +00:00
|
|
|
|
|
|
|
// Thermocouple open
|
|
|
|
max6675_temp = 4 * (
|
|
|
|
#if COUNT_6675 > 1
|
|
|
|
hindex ? HEATER_1_MAX6675_TMAX : HEATER_0_MAX6675_TMAX
|
|
|
|
#else
|
2020-07-11 05:23:48 +00:00
|
|
|
TERN(HEATER_1_USES_MAX6675, HEATER_1_MAX6675_TMAX, HEATER_0_MAX6675_TMAX)
|
2020-05-20 20:38:29 +00:00
|
|
|
#endif
|
|
|
|
);
|
|
|
|
}
|
2020-07-11 05:23:48 +00:00
|
|
|
else
|
2020-05-20 20:38:29 +00:00
|
|
|
max6675_temp >>= MAX6675_DISCARD_BITS;
|
2016-10-09 22:12:50 +00:00
|
|
|
}
|
2020-05-20 20:38:29 +00:00
|
|
|
else {
|
2016-03-08 14:58:11 +00:00
|
|
|
max6675_temp >>= MAX6675_DISCARD_BITS;
|
2020-05-20 20:38:29 +00:00
|
|
|
max6675_errors[hindex] = 0;
|
|
|
|
}
|
2019-01-14 20:29:55 +00:00
|
|
|
|
|
|
|
#if ENABLED(MAX6675_IS_MAX31855)
|
|
|
|
if (max6675_temp & 0x00002000) max6675_temp |= 0xFFFFC000; // Support negative temperature
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if COUNT_6675 > 1
|
|
|
|
max6675_temp_previous[hindex] = max6675_temp;
|
|
|
|
#endif
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
return int(max6675_temp);
|
2015-02-24 12:46:11 +00:00
|
|
|
}
|
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
#endif // HAS_MAX6675
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2016-04-29 01:18:13 +00:00
|
|
|
/**
|
2020-01-26 23:39:45 +00:00
|
|
|
* Update raw temperatures
|
2016-04-29 01:18:13 +00:00
|
|
|
*/
|
2020-01-26 23:39:45 +00:00
|
|
|
void Temperature::update_raw_temperatures() {
|
2018-11-17 00:20:33 +00:00
|
|
|
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_0 && DISABLED(HEATER_0_USES_MAX6675)
|
2019-09-06 00:44:55 +00:00
|
|
|
temp_hotend[0].update();
|
2015-03-25 10:08:24 +00:00
|
|
|
#endif
|
2018-11-17 00:20:33 +00:00
|
|
|
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_1
|
2015-07-31 05:29:30 +00:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2019-03-07 08:09:39 +00:00
|
|
|
redundant_temperature_raw = temp_hotend[1].acc;
|
2018-11-17 00:20:33 +00:00
|
|
|
#elif DISABLED(HEATER_1_USES_MAX6675)
|
2019-09-06 00:44:55 +00:00
|
|
|
temp_hotend[1].update();
|
2015-03-26 23:22:21 +00:00
|
|
|
#endif
|
2020-02-01 21:18:01 +00:00
|
|
|
#endif
|
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HAS_TEMP_ADC_2, temp_hotend[2].update());
|
|
|
|
TERN_(HAS_TEMP_ADC_3, temp_hotend[3].update());
|
|
|
|
TERN_(HAS_TEMP_ADC_4, temp_hotend[4].update());
|
|
|
|
TERN_(HAS_TEMP_ADC_5, temp_hotend[5].update());
|
|
|
|
TERN_(HAS_TEMP_ADC_6, temp_hotend[6].update());
|
|
|
|
TERN_(HAS_TEMP_ADC_7, temp_hotend[7].update());
|
|
|
|
TERN_(HAS_HEATED_BED, temp_bed.update());
|
|
|
|
TERN_(HAS_TEMP_CHAMBER, temp_chamber.update());
|
|
|
|
TERN_(HAS_TEMP_PROBE, temp_probe.update());
|
2019-03-07 08:09:39 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HAS_JOY_ADC_X, joystick.x.update());
|
|
|
|
TERN_(HAS_JOY_ADC_Y, joystick.y.update());
|
|
|
|
TERN_(HAS_JOY_ADC_Z, joystick.z.update());
|
2019-09-08 05:55:34 +00:00
|
|
|
|
2020-01-26 23:39:45 +00:00
|
|
|
raw_temps_ready = true;
|
2015-03-25 10:08:24 +00:00
|
|
|
}
|
|
|
|
|
2018-07-26 08:59:19 +00:00
|
|
|
void Temperature::readings_ready() {
|
2019-05-28 20:36:03 +00:00
|
|
|
|
2018-07-26 08:59:19 +00:00
|
|
|
// Update the raw values if they've been read. Else we could be updating them during reading.
|
2020-01-26 23:39:45 +00:00
|
|
|
if (!raw_temps_ready) update_raw_temperatures();
|
2018-07-26 08:59:19 +00:00
|
|
|
|
|
|
|
// Filament Sensor - can be read any time since IIR filtering is used
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(FILAMENT_WIDTH_SENSOR, filwidth.reading_ready());
|
2018-07-26 08:59:19 +00:00
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-09-10 07:20:49 +00:00
|
|
|
HOTEND_LOOP() temp_hotend[e].reset();
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(TEMP_SENSOR_1_AS_REDUNDANT, temp_hotend[1].reset());
|
2019-08-07 04:25:47 +00:00
|
|
|
#endif
|
2018-07-26 08:59:19 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HAS_HEATED_BED, temp_bed.reset());
|
|
|
|
TERN_(HAS_TEMP_CHAMBER, temp_chamber.reset());
|
|
|
|
TERN_(HAS_TEMP_PROBE, temp_probe.reset());
|
2018-07-26 08:59:19 +00:00
|
|
|
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HAS_JOY_ADC_X, joystick.x.reset());
|
|
|
|
TERN_(HAS_JOY_ADC_Y, joystick.y.reset());
|
|
|
|
TERN_(HAS_JOY_ADC_Z, joystick.z.reset());
|
2019-09-08 05:55:34 +00:00
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-09-10 07:20:49 +00:00
|
|
|
|
|
|
|
static constexpr int8_t temp_dir[] = {
|
2020-04-27 09:35:20 +00:00
|
|
|
TERN(HEATER_0_USES_MAX6675, 0, TEMPDIR(0))
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_MULTI_HOTEND
|
2020-04-27 09:35:20 +00:00
|
|
|
, TERN(HEATER_1_USES_MAX6675, 0, TEMPDIR(1))
|
2019-09-10 07:20:49 +00:00
|
|
|
#if HOTENDS > 2
|
2020-04-27 09:35:20 +00:00
|
|
|
#define _TEMPDIR(N) , TEMPDIR(N)
|
2019-11-09 23:59:04 +00:00
|
|
|
REPEAT_S(2, HOTENDS, _TEMPDIR)
|
2020-04-27 09:35:20 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
2019-09-10 07:20:49 +00:00
|
|
|
};
|
|
|
|
|
2020-03-14 04:18:16 +00:00
|
|
|
LOOP_L_N(e, COUNT(temp_dir)) {
|
2019-09-10 07:20:49 +00:00
|
|
|
const int8_t tdir = temp_dir[e];
|
|
|
|
if (tdir) {
|
|
|
|
const int16_t rawtemp = temp_hotend[e].raw * tdir; // normal direction, +rawtemp, else -rawtemp
|
|
|
|
const bool heater_on = (temp_hotend[e].target > 0
|
2020-04-22 21:35:03 +00:00
|
|
|
|| TERN0(PIDTEMP, temp_hotend[e].soft_pwm_amount) > 0
|
2019-09-10 07:20:49 +00:00
|
|
|
);
|
2020-09-13 23:06:14 +00:00
|
|
|
if (rawtemp > temp_range[e].raw_max * tdir) max_temp_error((heater_id_t)e);
|
2019-09-10 07:20:49 +00:00
|
|
|
if (heater_on && rawtemp < temp_range[e].raw_min * tdir && !is_preheating(e)) {
|
|
|
|
#ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
|
|
|
|
if (++consecutive_low_temperature_error[e] >= MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED)
|
|
|
|
#endif
|
2020-09-13 23:06:14 +00:00
|
|
|
min_temp_error((heater_id_t)e);
|
2019-09-10 07:20:49 +00:00
|
|
|
}
|
2019-07-01 14:40:54 +00:00
|
|
|
#ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
|
2019-09-10 07:20:49 +00:00
|
|
|
else
|
|
|
|
consecutive_low_temperature_error[e] = 0;
|
2019-07-01 14:40:54 +00:00
|
|
|
#endif
|
|
|
|
}
|
2018-07-26 08:59:19 +00:00
|
|
|
}
|
2019-09-10 07:20:49 +00:00
|
|
|
|
2020-07-01 21:27:28 +00:00
|
|
|
#endif // HAS_HOTEND
|
2018-07-26 08:59:19 +00:00
|
|
|
|
|
|
|
#if HAS_HEATED_BED
|
2019-03-07 08:09:39 +00:00
|
|
|
#if TEMPDIR(BED) < 0
|
2020-04-27 11:34:53 +00:00
|
|
|
#define BEDCMP(A,B) ((A)<(B))
|
2018-07-26 08:59:19 +00:00
|
|
|
#else
|
2020-04-27 11:34:53 +00:00
|
|
|
#define BEDCMP(A,B) ((A)>(B))
|
2018-07-26 08:59:19 +00:00
|
|
|
#endif
|
2020-04-22 21:35:03 +00:00
|
|
|
const bool bed_on = temp_bed.target > 0
|
|
|
|
|| TERN0(PIDTEMPBED, temp_bed.soft_pwm_amount) > 0
|
2018-07-26 08:59:19 +00:00
|
|
|
;
|
2019-07-02 13:39:55 +00:00
|
|
|
if (BEDCMP(temp_bed.raw, maxtemp_raw_BED)) max_temp_error(H_BED);
|
|
|
|
if (bed_on && BEDCMP(mintemp_raw_BED, temp_bed.raw)) min_temp_error(H_BED);
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif
|
|
|
|
|
2019-03-10 14:51:13 +00:00
|
|
|
#if HAS_HEATED_CHAMBER
|
|
|
|
#if TEMPDIR(CHAMBER) < 0
|
2020-04-27 11:34:53 +00:00
|
|
|
#define CHAMBERCMP(A,B) ((A)<(B))
|
2019-03-07 08:09:39 +00:00
|
|
|
#else
|
2020-04-27 11:34:53 +00:00
|
|
|
#define CHAMBERCMP(A,B) ((A)>(B))
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif
|
2019-04-12 20:38:10 +00:00
|
|
|
const bool chamber_on = (temp_chamber.target > 0);
|
2019-07-02 13:39:55 +00:00
|
|
|
if (CHAMBERCMP(temp_chamber.raw, maxtemp_raw_CHAMBER)) max_temp_error(H_CHAMBER);
|
|
|
|
if (chamber_on && CHAMBERCMP(mintemp_raw_CHAMBER, temp_chamber.raw)) min_temp_error(H_CHAMBER);
|
2018-07-26 08:59:19 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
/**
|
2016-08-28 01:06:26 +00:00
|
|
|
* Timer 0 is shared with millies so don't change the prescaler.
|
|
|
|
*
|
2017-12-09 04:13:03 +00:00
|
|
|
* On AVR this ISR uses the compare method so it runs at the base
|
2016-10-09 15:06:31 +00:00
|
|
|
* frequency (16 MHz / 64 / 256 = 976.5625 Hz), but at the TCNT0 set
|
2016-08-28 01:06:26 +00:00
|
|
|
* in OCR0B above (128 or halfway between OVFs).
|
|
|
|
*
|
2015-04-14 00:17:36 +00:00
|
|
|
* - Manage PWM to all the heaters and fan
|
2017-03-06 07:43:08 +00:00
|
|
|
* - Prepare or Measure one of the raw ADC sensor values
|
|
|
|
* - Check new temperature values for MIN/MAX errors (kill on error)
|
2015-04-14 00:17:36 +00:00
|
|
|
* - Step the babysteps value for each axis towards 0
|
2017-03-06 07:43:08 +00:00
|
|
|
* - For PINS_DEBUGGING, monitor and report endstop pins
|
|
|
|
* - For ENDSTOP_INTERRUPTS_FEATURE check endstops if flagged
|
2018-05-09 05:17:53 +00:00
|
|
|
* - Call planner.tick to count down its "ignore" time
|
2015-04-14 00:17:36 +00:00
|
|
|
*/
|
2019-03-11 01:43:59 +00:00
|
|
|
HAL_TEMP_TIMER_ISR() {
|
2017-08-24 17:18:54 +00:00
|
|
|
HAL_timer_isr_prologue(TEMP_TIMER_NUM);
|
2018-04-24 03:05:07 +00:00
|
|
|
|
2019-11-13 01:23:02 +00:00
|
|
|
Temperature::tick();
|
2016-04-29 01:18:13 +00:00
|
|
|
|
2018-04-24 03:05:07 +00:00
|
|
|
HAL_timer_isr_epilogue(TEMP_TIMER_NUM);
|
|
|
|
}
|
2017-02-12 17:00:14 +00:00
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
#if ENABLED(SLOW_PWM_HEATERS) && !defined(MIN_STATE_TIME)
|
|
|
|
#define MIN_STATE_TIME 16 // MIN_STATE_TIME * 65.5 = time in milliseconds
|
|
|
|
#endif
|
|
|
|
|
|
|
|
class SoftPWM {
|
|
|
|
public:
|
|
|
|
uint8_t count;
|
|
|
|
inline bool add(const uint8_t mask, const uint8_t amount) {
|
|
|
|
count = (count & mask) + amount; return (count > mask);
|
|
|
|
}
|
|
|
|
#if ENABLED(SLOW_PWM_HEATERS)
|
|
|
|
bool state_heater;
|
|
|
|
uint8_t state_timer_heater;
|
|
|
|
inline void dec() { if (state_timer_heater > 0) state_timer_heater--; }
|
|
|
|
inline bool ready(const bool v) {
|
|
|
|
const bool rdy = !state_timer_heater;
|
|
|
|
if (rdy && state_heater != v) {
|
|
|
|
state_heater = v;
|
|
|
|
state_timer_heater = MIN_STATE_TIME;
|
|
|
|
}
|
|
|
|
return rdy;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2019-11-13 01:23:02 +00:00
|
|
|
/**
|
|
|
|
* Handle various ~1KHz tasks associated with temperature
|
|
|
|
* - Heater PWM (~1KHz with scaler)
|
|
|
|
* - LCD Button polling (~500Hz)
|
|
|
|
* - Start / Read one ADC sensor
|
|
|
|
* - Advance Babysteps
|
|
|
|
* - Endstop polling
|
|
|
|
* - Planner clean buffer
|
|
|
|
*/
|
|
|
|
void Temperature::tick() {
|
2015-04-14 00:17:36 +00:00
|
|
|
|
2017-04-06 23:42:57 +00:00
|
|
|
static int8_t temp_count = -1;
|
|
|
|
static ADCSensorState adc_sensor_state = StartupDelay;
|
2016-09-24 05:51:21 +00:00
|
|
|
static uint8_t pwm_count = _BV(SOFT_PWM_SCALE);
|
2019-11-13 01:23:02 +00:00
|
|
|
|
2017-03-14 19:24:17 +00:00
|
|
|
// avoid multiple loads of pwm_count
|
|
|
|
uint8_t pwm_count_tmp = pwm_count;
|
2018-11-03 03:29:32 +00:00
|
|
|
|
2018-11-19 02:39:49 +00:00
|
|
|
#if HAS_ADC_BUTTONS
|
2017-06-10 05:12:18 +00:00
|
|
|
static unsigned int raw_ADCKey_value = 0;
|
2019-05-19 01:52:55 +00:00
|
|
|
static bool ADCKey_pressed = false;
|
2017-06-10 05:12:18 +00:00
|
|
|
#endif
|
2015-01-23 22:13:06 +00:00
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-09-10 07:20:49 +00:00
|
|
|
static SoftPWM soft_pwm_hotend[HOTENDS];
|
2019-03-07 08:09:39 +00:00
|
|
|
#endif
|
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2019-03-07 08:09:39 +00:00
|
|
|
static SoftPWM soft_pwm_bed;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_HEATED_CHAMBER
|
|
|
|
static SoftPWM soft_pwm_chamber;
|
2015-02-24 12:46:11 +00:00
|
|
|
#endif
|
2015-01-23 22:13:06 +00:00
|
|
|
|
2015-07-31 05:29:30 +00:00
|
|
|
#if DISABLED(SLOW_PWM_HEATERS)
|
2019-09-10 07:20:49 +00:00
|
|
|
|
2020-04-28 03:35:25 +00:00
|
|
|
#if HAS_HOTEND || HAS_HEATED_BED || HAS_HEATED_CHAMBER
|
2019-09-10 07:20:49 +00:00
|
|
|
constexpr uint8_t pwm_mask =
|
|
|
|
#if ENABLED(SOFT_PWM_DITHER)
|
|
|
|
_BV(SOFT_PWM_SCALE) - 1
|
|
|
|
#else
|
|
|
|
0
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
#define _PWM_MOD(N,S,T) do{ \
|
|
|
|
const bool on = S.add(pwm_mask, T.soft_pwm_amount); \
|
|
|
|
WRITE_HEATER_##N(on); \
|
|
|
|
}while(0)
|
|
|
|
#endif
|
2017-03-12 05:00:26 +00:00
|
|
|
|
2015-02-24 12:46:11 +00:00
|
|
|
/**
|
2018-11-29 01:28:31 +00:00
|
|
|
* Standard heater PWM modulation
|
2015-02-24 12:46:11 +00:00
|
|
|
*/
|
2017-03-14 19:24:17 +00:00
|
|
|
if (pwm_count_tmp >= 127) {
|
|
|
|
pwm_count_tmp -= 127;
|
2019-09-10 07:20:49 +00:00
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-11-09 23:59:04 +00:00
|
|
|
#define _PWM_MOD_E(N) _PWM_MOD(N,soft_pwm_hotend[N],temp_hotend[N]);
|
|
|
|
REPEAT(HOTENDS, _PWM_MOD_E);
|
|
|
|
#endif
|
2015-01-23 22:13:06 +00:00
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2019-03-07 08:09:39 +00:00
|
|
|
_PWM_MOD(BED,soft_pwm_bed,temp_bed);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_HEATED_CHAMBER
|
|
|
|
_PWM_MOD(CHAMBER,soft_pwm_chamber,temp_chamber);
|
2015-02-24 12:46:11 +00:00
|
|
|
#endif
|
2016-03-06 02:27:45 +00:00
|
|
|
|
2015-07-31 05:29:30 +00:00
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
2020-02-02 05:07:12 +00:00
|
|
|
#define _FAN_PWM(N) do{ \
|
|
|
|
uint8_t &spcf = soft_pwm_count_fan[N]; \
|
|
|
|
spcf = (spcf & pwm_mask) + (soft_pwm_amount_fan[N] >> 1); \
|
|
|
|
WRITE_FAN(N, spcf > pwm_mask ? HIGH : LOW); \
|
2019-03-07 08:09:39 +00:00
|
|
|
}while(0)
|
2016-03-06 02:27:45 +00:00
|
|
|
#if HAS_FAN0
|
2019-03-07 08:09:39 +00:00
|
|
|
_FAN_PWM(0);
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_FAN1
|
2019-03-07 08:09:39 +00:00
|
|
|
_FAN_PWM(1);
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_FAN2
|
2019-03-07 08:09:39 +00:00
|
|
|
_FAN_PWM(2);
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
#if HAS_FAN3
|
|
|
|
_FAN_PWM(3);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN4
|
|
|
|
_FAN_PWM(4);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN5
|
|
|
|
_FAN_PWM(5);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN6
|
|
|
|
_FAN_PWM(6);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN7
|
|
|
|
_FAN_PWM(7);
|
|
|
|
#endif
|
2015-02-24 12:46:11 +00:00
|
|
|
#endif
|
2015-01-23 22:13:06 +00:00
|
|
|
}
|
2017-03-18 19:28:57 +00:00
|
|
|
else {
|
2019-03-07 08:09:39 +00:00
|
|
|
#define _PWM_LOW(N,S) do{ if (S.count <= pwm_count_tmp) WRITE_HEATER_##N(LOW); }while(0)
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-11-09 23:59:04 +00:00
|
|
|
#define _PWM_LOW_E(N) _PWM_LOW(N, soft_pwm_hotend[N]);
|
|
|
|
REPEAT(HOTENDS, _PWM_LOW_E);
|
|
|
|
#endif
|
2017-03-18 19:28:57 +00:00
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2019-03-07 08:09:39 +00:00
|
|
|
_PWM_LOW(BED, soft_pwm_bed);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_HEATED_CHAMBER
|
|
|
|
_PWM_LOW(CHAMBER, soft_pwm_chamber);
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif
|
2017-03-18 19:28:57 +00:00
|
|
|
|
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
|
|
|
#if HAS_FAN0
|
2019-06-28 22:03:43 +00:00
|
|
|
if (soft_pwm_count_fan[0] <= pwm_count_tmp) WRITE_FAN(0, LOW);
|
2017-03-18 19:28:57 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_FAN1
|
2019-06-28 22:03:43 +00:00
|
|
|
if (soft_pwm_count_fan[1] <= pwm_count_tmp) WRITE_FAN(1, LOW);
|
2017-03-18 19:28:57 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_FAN2
|
2019-06-28 22:03:43 +00:00
|
|
|
if (soft_pwm_count_fan[2] <= pwm_count_tmp) WRITE_FAN(2, LOW);
|
2017-03-18 19:28:57 +00:00
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
#if HAS_FAN3
|
|
|
|
if (soft_pwm_count_fan[3] <= pwm_count_tmp) WRITE_FAN(3, LOW);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN4
|
|
|
|
if (soft_pwm_count_fan[4] <= pwm_count_tmp) WRITE_FAN(4, LOW);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN5
|
|
|
|
if (soft_pwm_count_fan[5] <= pwm_count_tmp) WRITE_FAN(5, LOW);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN6
|
|
|
|
if (soft_pwm_count_fan[6] <= pwm_count_tmp) WRITE_FAN(6, LOW);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN7
|
|
|
|
if (soft_pwm_count_fan[7] <= pwm_count_tmp) WRITE_FAN(7, LOW);
|
|
|
|
#endif
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif
|
2017-03-18 19:28:57 +00:00
|
|
|
}
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2016-10-09 15:06:31 +00:00
|
|
|
// SOFT_PWM_SCALE to frequency:
|
|
|
|
//
|
|
|
|
// 0: 16000000/64/256/128 = 7.6294 Hz
|
|
|
|
// 1: / 64 = 15.2588 Hz
|
|
|
|
// 2: / 32 = 30.5176 Hz
|
|
|
|
// 3: / 16 = 61.0352 Hz
|
|
|
|
// 4: / 8 = 122.0703 Hz
|
|
|
|
// 5: / 4 = 244.1406 Hz
|
2017-03-14 19:24:17 +00:00
|
|
|
pwm_count = pwm_count_tmp + _BV(SOFT_PWM_SCALE);
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2015-02-24 12:46:11 +00:00
|
|
|
#else // SLOW_PWM_HEATERS
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2016-03-25 06:19:46 +00:00
|
|
|
/**
|
2015-02-24 12:46:11 +00:00
|
|
|
* SLOW PWM HEATERS
|
|
|
|
*
|
2016-08-28 01:06:26 +00:00
|
|
|
* For relay-driven heaters
|
2015-02-24 12:46:11 +00:00
|
|
|
*/
|
2019-03-07 08:09:39 +00:00
|
|
|
#define _SLOW_SET(NR,PWM,V) do{ if (PWM.ready(V)) WRITE_HEATER_##NR(V); }while(0)
|
|
|
|
#define _SLOW_PWM(NR,PWM,SRC) do{ PWM.count = SRC.soft_pwm_amount; _SLOW_SET(NR,PWM,(PWM.count > 0)); }while(0)
|
|
|
|
#define _PWM_OFF(NR,PWM) do{ if (PWM.count < slow_pwm_count) _SLOW_SET(NR,PWM,0); }while(0)
|
2015-01-23 22:13:06 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
static uint8_t slow_pwm_count = 0;
|
|
|
|
|
2015-02-24 12:46:11 +00:00
|
|
|
if (slow_pwm_count == 0) {
|
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-11-09 23:59:04 +00:00
|
|
|
#define _SLOW_PWM_E(N) _SLOW_PWM(N, soft_pwm_hotend[N], temp_hotend[N]);
|
|
|
|
REPEAT(HOTENDS, _SLOW_PWM_E);
|
|
|
|
#endif
|
2019-03-07 08:09:39 +00:00
|
|
|
|
|
|
|
#if HAS_HEATED_BED
|
|
|
|
_SLOW_PWM(BED, soft_pwm_bed, temp_bed);
|
|
|
|
#endif
|
|
|
|
|
2020-07-01 21:27:28 +00:00
|
|
|
#if HAS_HEATED_CHAMBER
|
|
|
|
_SLOW_PWM(CHAMBER, soft_pwm_chamber, temp_chamber);
|
|
|
|
#endif
|
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
} // slow_pwm_count == 0
|
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-03-07 08:09:39 +00:00
|
|
|
#define _PWM_OFF_E(N) _PWM_OFF(N, soft_pwm_hotend[N]);
|
2019-11-09 23:59:04 +00:00
|
|
|
REPEAT(HOTENDS, _PWM_OFF_E);
|
|
|
|
#endif
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2019-03-07 08:09:39 +00:00
|
|
|
_PWM_OFF(BED, soft_pwm_bed);
|
2015-02-24 12:46:11 +00:00
|
|
|
#endif
|
|
|
|
|
2020-07-01 21:27:28 +00:00
|
|
|
#if HAS_HEATED_CHAMBER
|
|
|
|
_PWM_OFF(CHAMBER, soft_pwm_chamber);
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:29:30 +00:00
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
2017-03-14 19:24:17 +00:00
|
|
|
if (pwm_count_tmp >= 127) {
|
|
|
|
pwm_count_tmp = 0;
|
2019-06-28 22:03:43 +00:00
|
|
|
#define _PWM_FAN(N) do{ \
|
|
|
|
soft_pwm_count_fan[N] = soft_pwm_amount_fan[N] >> 1; \
|
|
|
|
WRITE_FAN(N, soft_pwm_count_fan[N] > 0 ? HIGH : LOW); \
|
2019-03-07 08:09:39 +00:00
|
|
|
}while(0)
|
2016-03-06 02:27:45 +00:00
|
|
|
#if HAS_FAN0
|
2019-06-28 22:03:43 +00:00
|
|
|
_PWM_FAN(0);
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_FAN1
|
2019-06-28 22:03:43 +00:00
|
|
|
_PWM_FAN(1);
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_FAN2
|
2019-06-28 22:03:43 +00:00
|
|
|
_PWM_FAN(2);
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
#if HAS_FAN3
|
|
|
|
_FAN_PWM(3);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN4
|
|
|
|
_FAN_PWM(4);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN5
|
|
|
|
_FAN_PWM(5);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN6
|
|
|
|
_FAN_PWM(6);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN7
|
|
|
|
_FAN_PWM(7);
|
|
|
|
#endif
|
2015-02-24 12:46:11 +00:00
|
|
|
}
|
2016-03-06 02:27:45 +00:00
|
|
|
#if HAS_FAN0
|
2019-06-28 22:03:43 +00:00
|
|
|
if (soft_pwm_count_fan[0] <= pwm_count_tmp) WRITE_FAN(0, LOW);
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_FAN1
|
2019-06-28 22:03:43 +00:00
|
|
|
if (soft_pwm_count_fan[1] <= pwm_count_tmp) WRITE_FAN(1, LOW);
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_FAN2
|
2019-06-28 22:03:43 +00:00
|
|
|
if (soft_pwm_count_fan[2] <= pwm_count_tmp) WRITE_FAN(2, LOW);
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
#if HAS_FAN3
|
|
|
|
if (soft_pwm_count_fan[3] <= pwm_count_tmp) WRITE_FAN(3, LOW);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN4
|
|
|
|
if (soft_pwm_count_fan[4] <= pwm_count_tmp) WRITE_FAN(4, LOW);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN5
|
|
|
|
if (soft_pwm_count_fan[5] <= pwm_count_tmp) WRITE_FAN(5, LOW);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN6
|
|
|
|
if (soft_pwm_count_fan[6] <= pwm_count_tmp) WRITE_FAN(6, LOW);
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN7
|
|
|
|
if (soft_pwm_count_fan[7] <= pwm_count_tmp) WRITE_FAN(7, LOW);
|
|
|
|
#endif
|
2017-03-23 09:20:25 +00:00
|
|
|
#endif // FAN_SOFT_PWM
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2016-10-09 15:06:31 +00:00
|
|
|
// SOFT_PWM_SCALE to frequency:
|
|
|
|
//
|
|
|
|
// 0: 16000000/64/256/128 = 7.6294 Hz
|
|
|
|
// 1: / 64 = 15.2588 Hz
|
|
|
|
// 2: / 32 = 30.5176 Hz
|
|
|
|
// 3: / 16 = 61.0352 Hz
|
|
|
|
// 4: / 8 = 122.0703 Hz
|
|
|
|
// 5: / 4 = 244.1406 Hz
|
2017-03-14 19:24:17 +00:00
|
|
|
pwm_count = pwm_count_tmp + _BV(SOFT_PWM_SCALE);
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2017-03-12 21:10:21 +00:00
|
|
|
// increment slow_pwm_count only every 64th pwm_count,
|
|
|
|
// i.e. yielding a PWM frequency of 16/128 Hz (8s).
|
2017-03-23 09:20:25 +00:00
|
|
|
if (((pwm_count >> SOFT_PWM_SCALE) & 0x3F) == 0) {
|
2015-02-24 12:46:11 +00:00
|
|
|
slow_pwm_count++;
|
2017-03-23 09:20:25 +00:00
|
|
|
slow_pwm_count &= 0x7F;
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
2019-11-09 23:59:04 +00:00
|
|
|
HOTEND_LOOP() soft_pwm_hotend[e].dec();
|
|
|
|
#endif
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(HAS_HEATED_BED, soft_pwm_bed.dec());
|
2020-07-01 21:27:28 +00:00
|
|
|
TERN_(HAS_HEATED_CHAMBER, soft_pwm_chamber.dec());
|
2020-04-22 21:35:03 +00:00
|
|
|
}
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2015-02-24 12:46:11 +00:00
|
|
|
#endif // SLOW_PWM_HEATERS
|
|
|
|
|
2017-04-06 23:42:57 +00:00
|
|
|
//
|
|
|
|
// Update lcd buttons 488 times per second
|
|
|
|
//
|
|
|
|
static bool do_buttons;
|
2018-11-11 18:16:24 +00:00
|
|
|
if ((do_buttons ^= true)) ui.update_buttons();
|
2017-04-06 23:42:57 +00:00
|
|
|
|
|
|
|
/**
|
2020-02-16 04:37:16 +00:00
|
|
|
* One sensor is sampled on every other call of the ISR.
|
|
|
|
* Each sensor is read 16 (OVERSAMPLENR) times, taking the average.
|
2017-04-06 23:42:57 +00:00
|
|
|
*
|
2020-02-16 04:37:16 +00:00
|
|
|
* On each Prepare pass, ADC is started for a sensor pin.
|
|
|
|
* On the next pass, the ADC value is read and accumulated.
|
2017-04-06 23:42:57 +00:00
|
|
|
*
|
2020-02-16 04:37:16 +00:00
|
|
|
* This gives each ADC 0.9765ms to charge up.
|
2017-04-06 23:42:57 +00:00
|
|
|
*/
|
2020-02-16 04:37:16 +00:00
|
|
|
#define ACCUMULATE_ADC(obj) do{ \
|
|
|
|
if (!HAL_ADC_READY()) next_sensor_state = adc_sensor_state; \
|
|
|
|
else obj.sample(HAL_READ_ADC()); \
|
2018-07-26 08:59:19 +00:00
|
|
|
}while(0)
|
|
|
|
|
2020-02-16 04:37:16 +00:00
|
|
|
ADCSensorState next_sensor_state = adc_sensor_state < SensorsReady ? (ADCSensorState)(int(adc_sensor_state) + 1) : StartSampling;
|
2020-02-16 01:10:46 +00:00
|
|
|
|
|
|
|
switch (adc_sensor_state) {
|
|
|
|
|
2017-04-06 23:42:57 +00:00
|
|
|
case SensorsReady: {
|
|
|
|
// All sensors have been read. Stay in this state for a few
|
|
|
|
// ISRs to save on calls to temp update/checking code below.
|
2017-06-15 20:14:08 +00:00
|
|
|
constexpr int8_t extra_loops = MIN_ADC_ISR_LOOPS - (int8_t)SensorsReady;
|
2017-04-06 23:42:57 +00:00
|
|
|
static uint8_t delay_count = 0;
|
|
|
|
if (extra_loops > 0) {
|
2018-07-26 08:59:19 +00:00
|
|
|
if (delay_count == 0) delay_count = extra_loops; // Init this delay
|
|
|
|
if (--delay_count) // While delaying...
|
|
|
|
next_sensor_state = SensorsReady; // retain this state (else, next state will be 0)
|
2020-02-16 04:37:16 +00:00
|
|
|
break;
|
2017-04-06 23:42:57 +00:00
|
|
|
}
|
2018-07-26 08:59:19 +00:00
|
|
|
else {
|
2020-02-16 04:37:16 +00:00
|
|
|
adc_sensor_state = StartSampling; // Fall-through to start sampling
|
|
|
|
next_sensor_state = (ADCSensorState)(int(StartSampling) + 1);
|
2018-07-26 08:59:19 +00:00
|
|
|
}
|
2017-04-06 23:42:57 +00:00
|
|
|
}
|
|
|
|
|
2018-07-26 08:59:19 +00:00
|
|
|
case StartSampling: // Start of sampling loops. Do updates/checks.
|
2020-02-16 04:37:16 +00:00
|
|
|
if (++temp_count >= OVERSAMPLENR) { // 10 * 16 * 1/(16000000/64/256) = 164ms.
|
2018-07-26 08:59:19 +00:00
|
|
|
temp_count = 0;
|
|
|
|
readings_ready();
|
|
|
|
}
|
2020-02-16 04:37:16 +00:00
|
|
|
break;
|
2018-07-26 08:59:19 +00:00
|
|
|
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_0
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareTemp_0: HAL_START_ADC(TEMP_0_PIN); break;
|
|
|
|
case MeasureTemp_0: ACCUMULATE_ADC(temp_hotend[0]); break;
|
2017-04-06 23:42:57 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareTemp_BED: HAL_START_ADC(TEMP_BED_PIN); break;
|
|
|
|
case MeasureTemp_BED: ACCUMULATE_ADC(temp_bed); break;
|
2017-04-06 23:42:57 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2018-02-24 06:38:58 +00:00
|
|
|
#if HAS_TEMP_CHAMBER
|
2019-09-06 01:01:38 +00:00
|
|
|
case PrepareTemp_CHAMBER: HAL_START_ADC(TEMP_CHAMBER_PIN); break;
|
2020-02-16 04:37:16 +00:00
|
|
|
case MeasureTemp_CHAMBER: ACCUMULATE_ADC(temp_chamber); break;
|
2018-02-24 06:38:58 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2020-01-17 23:16:45 +00:00
|
|
|
#if HAS_TEMP_PROBE
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareTemp_PROBE: HAL_START_ADC(TEMP_PROBE_PIN); break;
|
|
|
|
case MeasureTemp_PROBE: ACCUMULATE_ADC(temp_probe); break;
|
2020-01-17 23:16:45 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_1
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareTemp_1: HAL_START_ADC(TEMP_1_PIN); break;
|
|
|
|
case MeasureTemp_1: ACCUMULATE_ADC(temp_hotend[1]); break;
|
2017-04-06 23:42:57 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_2
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareTemp_2: HAL_START_ADC(TEMP_2_PIN); break;
|
|
|
|
case MeasureTemp_2: ACCUMULATE_ADC(temp_hotend[2]); break;
|
2017-04-06 23:42:57 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_3
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareTemp_3: HAL_START_ADC(TEMP_3_PIN); break;
|
|
|
|
case MeasureTemp_3: ACCUMULATE_ADC(temp_hotend[3]); break;
|
2017-04-06 23:42:57 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2018-05-02 00:33:41 +00:00
|
|
|
#if HAS_TEMP_ADC_4
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareTemp_4: HAL_START_ADC(TEMP_4_PIN); break;
|
|
|
|
case MeasureTemp_4: ACCUMULATE_ADC(temp_hotend[4]); break;
|
2017-04-06 23:42:57 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2018-09-13 06:35:55 +00:00
|
|
|
#if HAS_TEMP_ADC_5
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareTemp_5: HAL_START_ADC(TEMP_5_PIN); break;
|
|
|
|
case MeasureTemp_5: ACCUMULATE_ADC(temp_hotend[5]); break;
|
2018-09-13 06:35:55 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2020-01-25 08:13:39 +00:00
|
|
|
#if HAS_TEMP_ADC_6
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareTemp_6: HAL_START_ADC(TEMP_6_PIN); break;
|
|
|
|
case MeasureTemp_6: ACCUMULATE_ADC(temp_hotend[6]); break;
|
2020-01-25 08:13:39 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2020-01-25 08:13:39 +00:00
|
|
|
#if HAS_TEMP_ADC_7
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareTemp_7: HAL_START_ADC(TEMP_7_PIN); break;
|
|
|
|
case MeasureTemp_7: ACCUMULATE_ADC(temp_hotend[7]); break;
|
2020-01-25 08:13:39 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2017-04-06 23:42:57 +00:00
|
|
|
#if ENABLED(FILAMENT_WIDTH_SENSOR)
|
2020-02-16 04:37:16 +00:00
|
|
|
case Prepare_FILWIDTH: HAL_START_ADC(FILWIDTH_PIN); break;
|
|
|
|
case Measure_FILWIDTH:
|
2020-06-18 20:23:03 +00:00
|
|
|
if (!HAL_ADC_READY()) next_sensor_state = adc_sensor_state; // Redo this state
|
|
|
|
else filwidth.accumulate(HAL_READ_ADC());
|
2020-02-16 04:37:16 +00:00
|
|
|
break;
|
2017-04-06 23:42:57 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2020-06-18 20:23:03 +00:00
|
|
|
#if ENABLED(POWER_MONITOR_CURRENT)
|
|
|
|
case Prepare_POWER_MONITOR_CURRENT:
|
|
|
|
HAL_START_ADC(POWER_MONITOR_CURRENT_PIN);
|
|
|
|
break;
|
|
|
|
case Measure_POWER_MONITOR_CURRENT:
|
|
|
|
if (!HAL_ADC_READY()) next_sensor_state = adc_sensor_state; // Redo this state
|
|
|
|
else power_monitor.add_current_sample(HAL_READ_ADC());
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(POWER_MONITOR_VOLTAGE)
|
|
|
|
case Prepare_POWER_MONITOR_VOLTAGE:
|
|
|
|
HAL_START_ADC(POWER_MONITOR_VOLTAGE_PIN);
|
|
|
|
break;
|
|
|
|
case Measure_POWER_MONITOR_VOLTAGE:
|
|
|
|
if (!HAL_ADC_READY()) next_sensor_state = adc_sensor_state; // Redo this state
|
|
|
|
else power_monitor.add_voltage_sample(HAL_READ_ADC());
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
2019-09-08 05:55:34 +00:00
|
|
|
#if HAS_JOY_ADC_X
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareJoy_X: HAL_START_ADC(JOY_X_PIN); break;
|
|
|
|
case MeasureJoy_X: ACCUMULATE_ADC(joystick.x); break;
|
2019-09-08 05:55:34 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2019-09-08 05:55:34 +00:00
|
|
|
#if HAS_JOY_ADC_Y
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareJoy_Y: HAL_START_ADC(JOY_Y_PIN); break;
|
|
|
|
case MeasureJoy_Y: ACCUMULATE_ADC(joystick.y); break;
|
2019-09-08 05:55:34 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2019-09-08 05:55:34 +00:00
|
|
|
#if HAS_JOY_ADC_Z
|
2020-02-16 04:37:16 +00:00
|
|
|
case PrepareJoy_Z: HAL_START_ADC(JOY_Z_PIN); break;
|
|
|
|
case MeasureJoy_Z: ACCUMULATE_ADC(joystick.z); break;
|
2019-09-08 05:55:34 +00:00
|
|
|
#endif
|
2020-02-16 04:37:16 +00:00
|
|
|
|
2018-11-19 02:39:49 +00:00
|
|
|
#if HAS_ADC_BUTTONS
|
2020-02-16 04:37:16 +00:00
|
|
|
#ifndef ADC_BUTTON_DEBOUNCE_DELAY
|
|
|
|
#define ADC_BUTTON_DEBOUNCE_DELAY 16
|
|
|
|
#endif
|
|
|
|
case Prepare_ADC_KEY: HAL_START_ADC(ADC_KEYPAD_PIN); break;
|
|
|
|
case Measure_ADC_KEY:
|
|
|
|
if (!HAL_ADC_READY())
|
|
|
|
next_sensor_state = adc_sensor_state; // redo this state
|
|
|
|
else if (ADCKey_count < ADC_BUTTON_DEBOUNCE_DELAY) {
|
|
|
|
raw_ADCKey_value = HAL_READ_ADC();
|
|
|
|
if (raw_ADCKey_value <= 900UL * HAL_ADC_RANGE / 1024UL) {
|
|
|
|
NOMORE(current_ADCKey_raw, raw_ADCKey_value);
|
|
|
|
ADCKey_count++;
|
|
|
|
}
|
|
|
|
else { //ADC Key release
|
|
|
|
if (ADCKey_count > 0) ADCKey_count++; else ADCKey_pressed = false;
|
|
|
|
if (ADCKey_pressed) {
|
|
|
|
ADCKey_count = 0;
|
|
|
|
current_ADCKey_raw = HAL_ADC_RANGE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ADCKey_count == ADC_BUTTON_DEBOUNCE_DELAY) ADCKey_pressed = true;
|
|
|
|
break;
|
|
|
|
#endif // HAS_ADC_BUTTONS
|
|
|
|
|
|
|
|
case StartupDelay: break;
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2017-04-06 23:42:57 +00:00
|
|
|
} // switch(adc_sensor_state)
|
2015-03-23 07:27:29 +00:00
|
|
|
|
2018-07-26 08:59:19 +00:00
|
|
|
// Go to the next state
|
|
|
|
adc_sensor_state = next_sensor_state;
|
2015-01-23 22:13:06 +00:00
|
|
|
|
2018-07-26 08:59:19 +00:00
|
|
|
//
|
|
|
|
// Additional ~1KHz Tasks
|
|
|
|
//
|
2017-04-06 23:42:57 +00:00
|
|
|
|
2020-02-16 03:42:28 +00:00
|
|
|
#if ENABLED(BABYSTEPPING) && DISABLED(INTEGRATED_BABYSTEPPING)
|
2019-04-06 23:04:34 +00:00
|
|
|
babystep.task();
|
2019-02-27 10:38:56 +00:00
|
|
|
#endif
|
2016-10-31 12:28:51 +00:00
|
|
|
|
2018-05-16 07:08:43 +00:00
|
|
|
// Poll endstops state, if required
|
|
|
|
endstops.poll();
|
2018-05-09 05:17:53 +00:00
|
|
|
|
|
|
|
// Periodically call the planner timer
|
|
|
|
planner.tick();
|
2011-11-15 21:50:43 +00:00
|
|
|
}
|
2017-09-16 09:44:37 +00:00
|
|
|
|
2018-03-07 07:53:50 +00:00
|
|
|
#if HAS_TEMP_SENSOR
|
2017-09-16 09:44:37 +00:00
|
|
|
|
|
|
|
#include "../gcode/gcode.h"
|
|
|
|
|
2017-11-05 14:49:38 +00:00
|
|
|
static void print_heater_state(const float &c, const float &t
|
2017-09-16 09:44:37 +00:00
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
2017-11-05 14:49:38 +00:00
|
|
|
, const float r
|
2017-09-16 09:44:37 +00:00
|
|
|
#endif
|
2020-09-13 23:06:14 +00:00
|
|
|
, const heater_id_t e=INDEX_NONE
|
2017-09-16 09:44:37 +00:00
|
|
|
) {
|
2019-06-28 02:29:53 +00:00
|
|
|
char k;
|
|
|
|
switch (e) {
|
|
|
|
#if HAS_TEMP_CHAMBER
|
2019-07-02 13:39:55 +00:00
|
|
|
case H_CHAMBER: k = 'C'; break;
|
2017-09-16 09:44:37 +00:00
|
|
|
#endif
|
2020-01-17 23:16:45 +00:00
|
|
|
#if HAS_TEMP_PROBE
|
|
|
|
case H_PROBE: k = 'P'; break;
|
|
|
|
#endif
|
2019-06-28 02:29:53 +00:00
|
|
|
#if HAS_TEMP_HOTEND
|
|
|
|
default: k = 'T'; break;
|
|
|
|
#if HAS_HEATED_BED
|
2019-07-02 13:39:55 +00:00
|
|
|
case H_BED: k = 'B'; break;
|
2019-06-28 02:29:53 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2019-07-02 13:39:55 +00:00
|
|
|
case H_REDUNDANT: k = 'R'; break;
|
2019-06-28 02:29:53 +00:00
|
|
|
#endif
|
|
|
|
#elif HAS_HEATED_BED
|
|
|
|
default: k = 'B'; break;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
SERIAL_CHAR(' ');
|
|
|
|
SERIAL_CHAR(k);
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_MULTI_HOTEND
|
2019-02-24 04:53:01 +00:00
|
|
|
if (e >= 0) SERIAL_CHAR('0' + e);
|
2017-09-16 09:44:37 +00:00
|
|
|
#endif
|
2019-02-24 04:53:01 +00:00
|
|
|
SERIAL_CHAR(':');
|
|
|
|
SERIAL_ECHO(c);
|
|
|
|
SERIAL_ECHOPAIR(" /" , t);
|
2017-09-16 09:44:37 +00:00
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
2019-06-28 02:29:53 +00:00
|
|
|
SERIAL_ECHOPAIR(" (", r * RECIPROCAL(OVERSAMPLENR));
|
2019-02-24 04:53:01 +00:00
|
|
|
SERIAL_CHAR(')');
|
2017-09-16 09:44:37 +00:00
|
|
|
#endif
|
2018-01-20 20:13:17 +00:00
|
|
|
delay(2);
|
2017-09-16 09:44:37 +00:00
|
|
|
}
|
|
|
|
|
2019-06-28 02:29:53 +00:00
|
|
|
void Temperature::print_heater_states(const uint8_t target_extruder
|
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
|
|
|
, const bool include_r/*=false*/
|
|
|
|
#endif
|
|
|
|
) {
|
2017-09-16 09:44:37 +00:00
|
|
|
#if HAS_TEMP_HOTEND
|
2018-11-14 23:33:04 +00:00
|
|
|
print_heater_state(degHotend(target_extruder), degTargetHotend(target_extruder)
|
2017-09-16 09:44:37 +00:00
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
2018-11-14 23:33:04 +00:00
|
|
|
, rawHotendTemp(target_extruder)
|
2017-09-16 09:44:37 +00:00
|
|
|
#endif
|
|
|
|
);
|
2019-06-28 02:29:53 +00:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
|
|
|
if (include_r) print_heater_state(redundant_temperature, degTargetHotend(target_extruder)
|
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
|
|
|
, redundant_temperature_raw
|
|
|
|
#endif
|
2019-07-02 13:39:55 +00:00
|
|
|
, H_REDUNDANT
|
2019-06-28 02:29:53 +00:00
|
|
|
);
|
|
|
|
#endif
|
2017-09-16 09:44:37 +00:00
|
|
|
#endif
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2018-01-02 00:24:54 +00:00
|
|
|
print_heater_state(degBed(), degTargetBed()
|
2017-09-16 09:44:37 +00:00
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
2018-01-02 00:24:54 +00:00
|
|
|
, rawBedTemp()
|
2017-09-16 09:44:37 +00:00
|
|
|
#endif
|
2019-07-02 13:39:55 +00:00
|
|
|
, H_BED
|
2017-09-16 09:44:37 +00:00
|
|
|
);
|
|
|
|
#endif
|
2018-02-24 06:38:58 +00:00
|
|
|
#if HAS_TEMP_CHAMBER
|
2019-05-05 03:51:47 +00:00
|
|
|
print_heater_state(degChamber()
|
|
|
|
#if HAS_HEATED_CHAMBER
|
|
|
|
, degTargetChamber()
|
|
|
|
#else
|
|
|
|
, 0
|
|
|
|
#endif
|
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
|
|
|
, rawChamberTemp()
|
|
|
|
#endif
|
2019-07-02 13:39:55 +00:00
|
|
|
, H_CHAMBER
|
2018-02-24 06:38:58 +00:00
|
|
|
);
|
2019-05-05 03:51:47 +00:00
|
|
|
#endif // HAS_TEMP_CHAMBER
|
2020-01-17 23:16:45 +00:00
|
|
|
#if HAS_TEMP_PROBE
|
|
|
|
print_heater_state(degProbe(), 0
|
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
|
|
|
, rawProbeTemp()
|
|
|
|
#endif
|
|
|
|
, H_PROBE
|
|
|
|
);
|
|
|
|
#endif // HAS_TEMP_PROBE
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_MULTI_HOTEND
|
2018-01-02 00:24:54 +00:00
|
|
|
HOTEND_LOOP() print_heater_state(degHotend(e), degTargetHotend(e)
|
2017-09-16 09:44:37 +00:00
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
2018-01-02 00:24:54 +00:00
|
|
|
, rawHotendTemp(e)
|
2017-09-16 09:44:37 +00:00
|
|
|
#endif
|
2020-09-13 23:06:14 +00:00
|
|
|
, (heater_id_t)e
|
2017-09-16 09:44:37 +00:00
|
|
|
);
|
|
|
|
#endif
|
2020-09-13 23:06:14 +00:00
|
|
|
SERIAL_ECHOPAIR(" @:", getHeaterPower((heater_id_t)target_extruder));
|
2018-04-23 22:13:01 +00:00
|
|
|
#if HAS_HEATED_BED
|
2019-07-02 13:39:55 +00:00
|
|
|
SERIAL_ECHOPAIR(" B@:", getHeaterPower(H_BED));
|
2019-04-12 20:38:10 +00:00
|
|
|
#endif
|
|
|
|
#if HAS_HEATED_CHAMBER
|
2019-07-02 13:39:55 +00:00
|
|
|
SERIAL_ECHOPAIR(" C@:", getHeaterPower(H_CHAMBER));
|
2017-09-16 09:44:37 +00:00
|
|
|
#endif
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_MULTI_HOTEND
|
2017-09-16 09:44:37 +00:00
|
|
|
HOTEND_LOOP() {
|
2019-02-24 04:53:01 +00:00
|
|
|
SERIAL_ECHOPAIR(" @", e);
|
|
|
|
SERIAL_CHAR(':');
|
2020-09-13 23:06:14 +00:00
|
|
|
SERIAL_ECHO(getHeaterPower((heater_id_t)e));
|
2017-09-16 09:44:37 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2017-09-16 18:05:01 +00:00
|
|
|
#if ENABLED(AUTO_REPORT_TEMPERATURES)
|
|
|
|
|
|
|
|
uint8_t Temperature::auto_report_temp_interval;
|
|
|
|
millis_t Temperature::next_temp_report_ms;
|
|
|
|
|
|
|
|
void Temperature::auto_report_temperatures() {
|
|
|
|
if (auto_report_temp_interval && ELAPSED(millis(), next_temp_report_ms)) {
|
|
|
|
next_temp_report_ms = millis() + 1000UL * auto_report_temp_interval;
|
2019-03-04 03:03:48 +00:00
|
|
|
PORT_REDIRECT(SERIAL_BOTH);
|
2018-11-14 23:33:04 +00:00
|
|
|
print_heater_states(active_extruder);
|
2017-09-16 18:05:01 +00:00
|
|
|
SERIAL_EOL();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // AUTO_REPORT_TEMPERATURES
|
|
|
|
|
2020-04-28 03:35:25 +00:00
|
|
|
#if HAS_HOTEND && HAS_DISPLAY
|
2018-10-07 22:06:14 +00:00
|
|
|
void Temperature::set_heating_message(const uint8_t e) {
|
|
|
|
const bool heating = isHeatingHotend(e);
|
2019-09-27 09:38:43 +00:00
|
|
|
ui.status_printf_P(0,
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_MULTI_HOTEND
|
2019-09-27 09:38:43 +00:00
|
|
|
PSTR("E%c " S_FMT), '1' + e
|
|
|
|
#else
|
|
|
|
PSTR("E " S_FMT)
|
|
|
|
#endif
|
2019-10-10 00:46:10 +00:00
|
|
|
, heating ? GET_TEXT(MSG_HEATING) : GET_TEXT(MSG_COOLING)
|
2019-09-27 09:38:43 +00:00
|
|
|
);
|
2018-10-07 22:06:14 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-09-29 06:44:47 +00:00
|
|
|
#if HAS_TEMP_HOTEND
|
|
|
|
|
|
|
|
#ifndef MIN_COOLING_SLOPE_DEG
|
|
|
|
#define MIN_COOLING_SLOPE_DEG 1.50
|
|
|
|
#endif
|
|
|
|
#ifndef MIN_COOLING_SLOPE_TIME
|
|
|
|
#define MIN_COOLING_SLOPE_TIME 60
|
|
|
|
#endif
|
|
|
|
|
2018-11-11 00:07:38 +00:00
|
|
|
bool Temperature::wait_for_hotend(const uint8_t target_extruder, const bool no_wait_for_cooling/*=true*/
|
|
|
|
#if G26_CLICK_CAN_CANCEL
|
|
|
|
, const bool click_to_cancel/*=false*/
|
|
|
|
#endif
|
|
|
|
) {
|
2020-05-03 05:32:25 +00:00
|
|
|
|
|
|
|
#if ENABLED(AUTOTEMP)
|
|
|
|
REMEMBER(1, planner.autotemp_enabled, false);
|
|
|
|
#endif
|
|
|
|
|
2018-09-29 06:44:47 +00:00
|
|
|
#if TEMP_RESIDENCY_TIME > 0
|
|
|
|
millis_t residency_start_ms = 0;
|
2020-01-15 07:55:26 +00:00
|
|
|
bool first_loop = true;
|
2018-09-29 06:44:47 +00:00
|
|
|
// Loop until the temperature has stabilized
|
2020-04-04 00:49:45 +00:00
|
|
|
#define TEMP_CONDITIONS (!residency_start_ms || PENDING(now, residency_start_ms + SEC_TO_MS(TEMP_RESIDENCY_TIME)))
|
2018-09-29 06:44:47 +00:00
|
|
|
#else
|
|
|
|
// Loop until the temperature is very close target
|
|
|
|
#define TEMP_CONDITIONS (wants_to_cool ? isCoolingHotend(target_extruder) : isHeatingHotend(target_extruder))
|
|
|
|
#endif
|
|
|
|
|
2018-09-29 22:03:23 +00:00
|
|
|
#if DISABLED(BUSY_WHILE_HEATING) && ENABLED(HOST_KEEPALIVE_FEATURE)
|
2018-09-29 06:44:47 +00:00
|
|
|
KEEPALIVE_STATE(NOT_BUSY);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(PRINTER_EVENT_LEDS)
|
|
|
|
const float start_temp = degHotend(target_extruder);
|
2018-10-11 02:25:43 +00:00
|
|
|
printerEventLEDs.onHotendHeatingStart();
|
2018-09-29 06:44:47 +00:00
|
|
|
#endif
|
|
|
|
|
2020-01-15 07:55:26 +00:00
|
|
|
bool wants_to_cool = false;
|
2020-09-12 03:51:19 +00:00
|
|
|
float target_temp = -1.0, old_temp = 9999.0;
|
2018-09-29 06:44:47 +00:00
|
|
|
millis_t now, next_temp_ms = 0, next_cool_check_ms = 0;
|
2020-09-12 03:51:19 +00:00
|
|
|
wait_for_heatup = true;
|
2018-09-29 06:44:47 +00:00
|
|
|
do {
|
|
|
|
// Target temperature might be changed during the loop
|
|
|
|
if (target_temp != degTargetHotend(target_extruder)) {
|
|
|
|
wants_to_cool = isCoolingHotend(target_extruder);
|
|
|
|
target_temp = degTargetHotend(target_extruder);
|
|
|
|
|
|
|
|
// Exit if S<lower>, continue if S<higher>, R<lower>, or R<higher>
|
|
|
|
if (no_wait_for_cooling && wants_to_cool) break;
|
|
|
|
}
|
|
|
|
|
|
|
|
now = millis();
|
2018-11-14 23:33:04 +00:00
|
|
|
if (ELAPSED(now, next_temp_ms)) { // Print temp & remaining time every 1s while waiting
|
2018-09-29 06:44:47 +00:00
|
|
|
next_temp_ms = now + 1000UL;
|
2018-11-14 23:33:04 +00:00
|
|
|
print_heater_states(target_extruder);
|
2018-09-29 06:44:47 +00:00
|
|
|
#if TEMP_RESIDENCY_TIME > 0
|
2018-11-29 22:58:58 +00:00
|
|
|
SERIAL_ECHOPGM(" W:");
|
2018-09-29 06:44:47 +00:00
|
|
|
if (residency_start_ms)
|
2020-04-04 00:49:45 +00:00
|
|
|
SERIAL_ECHO(long((SEC_TO_MS(TEMP_RESIDENCY_TIME) - (now - residency_start_ms)) / 1000UL));
|
2018-09-29 06:44:47 +00:00
|
|
|
else
|
2018-11-29 22:58:58 +00:00
|
|
|
SERIAL_CHAR('?');
|
2018-09-29 06:44:47 +00:00
|
|
|
#endif
|
|
|
|
SERIAL_EOL();
|
|
|
|
}
|
|
|
|
|
2019-09-03 00:21:47 +00:00
|
|
|
idle();
|
2018-09-29 06:44:47 +00:00
|
|
|
gcode.reset_stepper_timeout(); // Keep steppers powered
|
|
|
|
|
|
|
|
const float temp = degHotend(target_extruder);
|
|
|
|
|
|
|
|
#if ENABLED(PRINTER_EVENT_LEDS)
|
|
|
|
// Gradually change LED strip from violet to red as nozzle heats up
|
2018-10-11 02:25:43 +00:00
|
|
|
if (!wants_to_cool) printerEventLEDs.onHotendHeating(start_temp, temp, target_temp);
|
2018-09-29 06:44:47 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if TEMP_RESIDENCY_TIME > 0
|
|
|
|
|
|
|
|
const float temp_diff = ABS(target_temp - temp);
|
|
|
|
|
|
|
|
if (!residency_start_ms) {
|
|
|
|
// Start the TEMP_RESIDENCY_TIME timer when we reach target temp for the first time.
|
2020-07-07 06:50:57 +00:00
|
|
|
if (temp_diff < TEMP_WINDOW)
|
2020-07-06 23:52:21 +00:00
|
|
|
residency_start_ms = now + (first_loop ? SEC_TO_MS(TEMP_RESIDENCY_TIME) / 3 : 0);
|
2018-09-29 06:44:47 +00:00
|
|
|
}
|
|
|
|
else if (temp_diff > TEMP_HYSTERESIS) {
|
|
|
|
// Restart the timer whenever the temperature falls outside the hysteresis.
|
|
|
|
residency_start_ms = now;
|
|
|
|
}
|
|
|
|
|
2020-01-15 07:55:26 +00:00
|
|
|
first_loop = false;
|
|
|
|
|
2018-09-29 06:44:47 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// Prevent a wait-forever situation if R is misused i.e. M109 R0
|
|
|
|
if (wants_to_cool) {
|
|
|
|
// break after MIN_COOLING_SLOPE_TIME seconds
|
|
|
|
// if the temperature did not drop at least MIN_COOLING_SLOPE_DEG
|
|
|
|
if (!next_cool_check_ms || ELAPSED(now, next_cool_check_ms)) {
|
|
|
|
if (old_temp - temp < float(MIN_COOLING_SLOPE_DEG)) break;
|
|
|
|
next_cool_check_ms = now + 1000UL * MIN_COOLING_SLOPE_TIME;
|
|
|
|
old_temp = temp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-11 00:07:38 +00:00
|
|
|
#if G26_CLICK_CAN_CANCEL
|
2018-11-11 18:16:24 +00:00
|
|
|
if (click_to_cancel && ui.use_click()) {
|
2018-11-11 00:07:38 +00:00
|
|
|
wait_for_heatup = false;
|
2018-11-11 18:16:24 +00:00
|
|
|
ui.quick_feedback();
|
2018-11-11 00:07:38 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-09-29 06:44:47 +00:00
|
|
|
} while (wait_for_heatup && TEMP_CONDITIONS);
|
|
|
|
|
|
|
|
if (wait_for_heatup) {
|
2020-09-12 03:51:19 +00:00
|
|
|
wait_for_heatup = false;
|
2020-06-16 06:45:27 +00:00
|
|
|
#if ENABLED(DWIN_CREALITY_LCD)
|
|
|
|
HMI_flag.heat_flag = 0;
|
|
|
|
duration_t elapsed = print_job_timer.duration(); // print timer
|
2020-06-25 00:44:50 +00:00
|
|
|
dwin_heat_time = elapsed.value;
|
2020-06-16 06:45:27 +00:00
|
|
|
#else
|
|
|
|
ui.reset_status();
|
|
|
|
#endif
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(PRINTER_EVENT_LEDS, printerEventLEDs.onHeatingDone());
|
2020-09-12 03:51:19 +00:00
|
|
|
return true;
|
2018-09-29 06:44:47 +00:00
|
|
|
}
|
|
|
|
|
2020-09-12 03:51:19 +00:00
|
|
|
return false;
|
2018-09-29 06:44:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // HAS_TEMP_HOTEND
|
|
|
|
|
|
|
|
#if HAS_HEATED_BED
|
|
|
|
|
|
|
|
#ifndef MIN_COOLING_SLOPE_DEG_BED
|
2020-05-04 22:23:35 +00:00
|
|
|
#define MIN_COOLING_SLOPE_DEG_BED 1.00
|
2018-09-29 06:44:47 +00:00
|
|
|
#endif
|
|
|
|
#ifndef MIN_COOLING_SLOPE_TIME_BED
|
|
|
|
#define MIN_COOLING_SLOPE_TIME_BED 60
|
|
|
|
#endif
|
|
|
|
|
2018-11-26 00:05:18 +00:00
|
|
|
bool Temperature::wait_for_bed(const bool no_wait_for_cooling/*=true*/
|
2018-11-11 00:07:38 +00:00
|
|
|
#if G26_CLICK_CAN_CANCEL
|
|
|
|
, const bool click_to_cancel/*=false*/
|
|
|
|
#endif
|
|
|
|
) {
|
2018-09-29 06:44:47 +00:00
|
|
|
#if TEMP_BED_RESIDENCY_TIME > 0
|
|
|
|
millis_t residency_start_ms = 0;
|
2019-05-02 02:55:58 +00:00
|
|
|
bool first_loop = true;
|
2018-09-29 06:44:47 +00:00
|
|
|
// Loop until the temperature has stabilized
|
2020-04-04 00:49:45 +00:00
|
|
|
#define TEMP_BED_CONDITIONS (!residency_start_ms || PENDING(now, residency_start_ms + SEC_TO_MS(TEMP_BED_RESIDENCY_TIME)))
|
2018-09-29 06:44:47 +00:00
|
|
|
#else
|
|
|
|
// Loop until the temperature is very close target
|
|
|
|
#define TEMP_BED_CONDITIONS (wants_to_cool ? isCoolingBed() : isHeatingBed())
|
|
|
|
#endif
|
|
|
|
|
2018-09-29 22:03:23 +00:00
|
|
|
#if DISABLED(BUSY_WHILE_HEATING) && ENABLED(HOST_KEEPALIVE_FEATURE)
|
2018-09-29 06:44:47 +00:00
|
|
|
KEEPALIVE_STATE(NOT_BUSY);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(PRINTER_EVENT_LEDS)
|
|
|
|
const float start_temp = degBed();
|
2018-10-11 02:25:43 +00:00
|
|
|
printerEventLEDs.onBedHeatingStart();
|
2018-09-29 06:44:47 +00:00
|
|
|
#endif
|
|
|
|
|
2020-09-12 03:51:19 +00:00
|
|
|
bool wants_to_cool = false;
|
|
|
|
float target_temp = -1, old_temp = 9999;
|
|
|
|
millis_t now, next_temp_ms = 0, next_cool_check_ms = 0;
|
|
|
|
wait_for_heatup = true;
|
2018-09-29 06:44:47 +00:00
|
|
|
do {
|
|
|
|
// Target temperature might be changed during the loop
|
|
|
|
if (target_temp != degTargetBed()) {
|
|
|
|
wants_to_cool = isCoolingBed();
|
|
|
|
target_temp = degTargetBed();
|
|
|
|
|
|
|
|
// Exit if S<lower>, continue if S<higher>, R<lower>, or R<higher>
|
|
|
|
if (no_wait_for_cooling && wants_to_cool) break;
|
|
|
|
}
|
|
|
|
|
|
|
|
now = millis();
|
|
|
|
if (ELAPSED(now, next_temp_ms)) { //Print Temp Reading every 1 second while heating up.
|
|
|
|
next_temp_ms = now + 1000UL;
|
2018-11-14 23:33:04 +00:00
|
|
|
print_heater_states(active_extruder);
|
2018-09-29 06:44:47 +00:00
|
|
|
#if TEMP_BED_RESIDENCY_TIME > 0
|
2018-11-29 22:58:58 +00:00
|
|
|
SERIAL_ECHOPGM(" W:");
|
2018-09-29 06:44:47 +00:00
|
|
|
if (residency_start_ms)
|
2020-04-04 00:49:45 +00:00
|
|
|
SERIAL_ECHO(long((SEC_TO_MS(TEMP_BED_RESIDENCY_TIME) - (now - residency_start_ms)) / 1000UL));
|
2018-09-29 06:44:47 +00:00
|
|
|
else
|
2018-11-29 22:58:58 +00:00
|
|
|
SERIAL_CHAR('?');
|
2018-09-29 06:44:47 +00:00
|
|
|
#endif
|
|
|
|
SERIAL_EOL();
|
|
|
|
}
|
|
|
|
|
|
|
|
idle();
|
|
|
|
gcode.reset_stepper_timeout(); // Keep steppers powered
|
|
|
|
|
|
|
|
const float temp = degBed();
|
|
|
|
|
|
|
|
#if ENABLED(PRINTER_EVENT_LEDS)
|
|
|
|
// Gradually change LED strip from blue to violet as bed heats up
|
2018-10-11 02:25:43 +00:00
|
|
|
if (!wants_to_cool) printerEventLEDs.onBedHeating(start_temp, temp, target_temp);
|
2018-09-29 06:44:47 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if TEMP_BED_RESIDENCY_TIME > 0
|
|
|
|
|
|
|
|
const float temp_diff = ABS(target_temp - temp);
|
|
|
|
|
|
|
|
if (!residency_start_ms) {
|
|
|
|
// Start the TEMP_BED_RESIDENCY_TIME timer when we reach target temp for the first time.
|
2020-07-06 23:52:21 +00:00
|
|
|
if (temp_diff < TEMP_BED_WINDOW)
|
|
|
|
residency_start_ms = now + (first_loop ? SEC_TO_MS(TEMP_BED_RESIDENCY_TIME) / 3 : 0);
|
2018-09-29 06:44:47 +00:00
|
|
|
}
|
|
|
|
else if (temp_diff > TEMP_BED_HYSTERESIS) {
|
|
|
|
// Restart the timer whenever the temperature falls outside the hysteresis.
|
|
|
|
residency_start_ms = now;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // TEMP_BED_RESIDENCY_TIME > 0
|
|
|
|
|
|
|
|
// Prevent a wait-forever situation if R is misused i.e. M190 R0
|
|
|
|
if (wants_to_cool) {
|
|
|
|
// Break after MIN_COOLING_SLOPE_TIME_BED seconds
|
|
|
|
// if the temperature did not drop at least MIN_COOLING_SLOPE_DEG_BED
|
|
|
|
if (!next_cool_check_ms || ELAPSED(now, next_cool_check_ms)) {
|
|
|
|
if (old_temp - temp < float(MIN_COOLING_SLOPE_DEG_BED)) break;
|
|
|
|
next_cool_check_ms = now + 1000UL * MIN_COOLING_SLOPE_TIME_BED;
|
|
|
|
old_temp = temp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-11 00:07:38 +00:00
|
|
|
#if G26_CLICK_CAN_CANCEL
|
2018-11-11 18:16:24 +00:00
|
|
|
if (click_to_cancel && ui.use_click()) {
|
2018-11-11 00:07:38 +00:00
|
|
|
wait_for_heatup = false;
|
2018-11-11 18:16:24 +00:00
|
|
|
ui.quick_feedback();
|
2018-11-11 00:07:38 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-05-02 02:55:58 +00:00
|
|
|
#if TEMP_BED_RESIDENCY_TIME > 0
|
|
|
|
first_loop = false;
|
|
|
|
#endif
|
2019-02-28 20:35:05 +00:00
|
|
|
|
2018-09-29 06:44:47 +00:00
|
|
|
} while (wait_for_heatup && TEMP_BED_CONDITIONS);
|
|
|
|
|
2020-09-12 03:51:19 +00:00
|
|
|
if (wait_for_heatup) {
|
|
|
|
wait_for_heatup = false;
|
|
|
|
ui.reset_status();
|
|
|
|
return true;
|
|
|
|
}
|
2018-09-29 06:44:47 +00:00
|
|
|
|
2020-09-12 03:51:19 +00:00
|
|
|
return false;
|
2018-09-29 06:44:47 +00:00
|
|
|
}
|
|
|
|
|
2020-03-04 18:50:43 +00:00
|
|
|
void Temperature::wait_for_bed_heating() {
|
|
|
|
if (isHeatingBed()) {
|
|
|
|
SERIAL_ECHOLNPGM("Wait for bed heating...");
|
|
|
|
LCD_MESSAGEPGM(MSG_BED_HEATING);
|
|
|
|
wait_for_bed();
|
|
|
|
ui.reset_status();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-29 06:44:47 +00:00
|
|
|
#endif // HAS_HEATED_BED
|
|
|
|
|
2020-09-12 03:51:19 +00:00
|
|
|
#if HAS_TEMP_PROBE
|
|
|
|
|
|
|
|
#ifndef MIN_DELTA_SLOPE_DEG_PROBE
|
|
|
|
#define MIN_DELTA_SLOPE_DEG_PROBE 1.0
|
|
|
|
#endif
|
|
|
|
#ifndef MIN_DELTA_SLOPE_TIME_PROBE
|
|
|
|
#define MIN_DELTA_SLOPE_TIME_PROBE 600
|
|
|
|
#endif
|
|
|
|
|
|
|
|
bool Temperature::wait_for_probe(const float target_temp, bool no_wait_for_cooling/*=true*/) {
|
|
|
|
|
|
|
|
const bool wants_to_cool = isProbeAboveTemp(target_temp);
|
|
|
|
const bool will_wait = !(wants_to_cool && no_wait_for_cooling);
|
|
|
|
if (will_wait)
|
|
|
|
SERIAL_ECHOLNPAIR("Waiting for probe to ", (wants_to_cool ? PSTR("cool down") : PSTR("heat up")), " to ", target_temp, " degrees.");
|
|
|
|
|
|
|
|
#if DISABLED(BUSY_WHILE_HEATING) && ENABLED(HOST_KEEPALIVE_FEATURE)
|
|
|
|
KEEPALIVE_STATE(NOT_BUSY);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
float old_temp = 9999;
|
|
|
|
millis_t next_temp_ms = 0, next_delta_check_ms = 0;
|
|
|
|
wait_for_heatup = true;
|
|
|
|
while (will_wait && wait_for_heatup) {
|
|
|
|
|
|
|
|
// Print Temp Reading every 10 seconds while heating up.
|
|
|
|
millis_t now = millis();
|
|
|
|
if (!next_temp_ms || ELAPSED(now, next_temp_ms)) {
|
|
|
|
next_temp_ms = now + 10000UL;
|
|
|
|
print_heater_states(active_extruder);
|
|
|
|
SERIAL_EOL();
|
|
|
|
}
|
|
|
|
|
|
|
|
idle();
|
|
|
|
gcode.reset_stepper_timeout(); // Keep steppers powered
|
|
|
|
|
|
|
|
// Break after MIN_DELTA_SLOPE_TIME_PROBE seconds if the temperature
|
|
|
|
// did not drop at least MIN_DELTA_SLOPE_DEG_PROBE. This avoids waiting
|
|
|
|
// forever as the probe is not actively heated.
|
|
|
|
if (!next_delta_check_ms || ELAPSED(now, next_delta_check_ms)) {
|
|
|
|
const float temp = degProbe(),
|
|
|
|
delta_temp = old_temp > temp ? old_temp - temp : temp - old_temp;
|
|
|
|
if (delta_temp < float(MIN_DELTA_SLOPE_DEG_PROBE)) {
|
|
|
|
SERIAL_ECHOLNPGM("Timed out waiting for probe temperature.");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
next_delta_check_ms = now + 1000UL * MIN_DELTA_SLOPE_TIME_PROBE;
|
|
|
|
old_temp = temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Loop until the temperature is very close target
|
|
|
|
if (!(wants_to_cool ? isProbeAboveTemp(target_temp) : isProbeBelowTemp(target_temp))) {
|
|
|
|
SERIAL_ECHOLN(wants_to_cool ? PSTR("Cooldown") : PSTR("Heatup"));
|
|
|
|
SERIAL_ECHOLNPGM(" complete, target probe temperature reached.");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wait_for_heatup) {
|
|
|
|
wait_for_heatup = false;
|
|
|
|
ui.reset_status();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else if (will_wait)
|
|
|
|
SERIAL_ECHOLNPGM("Canceled wait for probe temperature.");
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // HAS_TEMP_PROBE
|
|
|
|
|
2019-10-16 20:02:37 +00:00
|
|
|
#if HAS_HEATED_CHAMBER
|
2019-05-05 03:51:47 +00:00
|
|
|
|
|
|
|
#ifndef MIN_COOLING_SLOPE_DEG_CHAMBER
|
|
|
|
#define MIN_COOLING_SLOPE_DEG_CHAMBER 1.50
|
|
|
|
#endif
|
|
|
|
#ifndef MIN_COOLING_SLOPE_TIME_CHAMBER
|
|
|
|
#define MIN_COOLING_SLOPE_TIME_CHAMBER 60
|
|
|
|
#endif
|
|
|
|
|
|
|
|
bool Temperature::wait_for_chamber(const bool no_wait_for_cooling/*=true*/) {
|
|
|
|
#if TEMP_CHAMBER_RESIDENCY_TIME > 0
|
|
|
|
millis_t residency_start_ms = 0;
|
2020-01-15 07:55:26 +00:00
|
|
|
bool first_loop = true;
|
2019-05-05 03:51:47 +00:00
|
|
|
// Loop until the temperature has stabilized
|
2020-04-04 00:49:45 +00:00
|
|
|
#define TEMP_CHAMBER_CONDITIONS (!residency_start_ms || PENDING(now, residency_start_ms + SEC_TO_MS(TEMP_CHAMBER_RESIDENCY_TIME)))
|
2019-05-05 03:51:47 +00:00
|
|
|
#else
|
|
|
|
// Loop until the temperature is very close target
|
|
|
|
#define TEMP_CHAMBER_CONDITIONS (wants_to_cool ? isCoolingChamber() : isHeatingChamber())
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if DISABLED(BUSY_WHILE_HEATING) && ENABLED(HOST_KEEPALIVE_FEATURE)
|
|
|
|
KEEPALIVE_STATE(NOT_BUSY);
|
|
|
|
#endif
|
|
|
|
|
2020-09-12 03:51:19 +00:00
|
|
|
bool wants_to_cool = false;
|
|
|
|
float target_temp = -1, old_temp = 9999;
|
|
|
|
millis_t now, next_temp_ms = 0, next_cool_check_ms = 0;
|
|
|
|
wait_for_heatup = true;
|
2019-05-05 03:51:47 +00:00
|
|
|
do {
|
|
|
|
// Target temperature might be changed during the loop
|
|
|
|
if (target_temp != degTargetChamber()) {
|
|
|
|
wants_to_cool = isCoolingChamber();
|
|
|
|
target_temp = degTargetChamber();
|
|
|
|
|
|
|
|
// Exit if S<lower>, continue if S<higher>, R<lower>, or R<higher>
|
|
|
|
if (no_wait_for_cooling && wants_to_cool) break;
|
|
|
|
}
|
|
|
|
|
|
|
|
now = millis();
|
2020-07-06 23:52:21 +00:00
|
|
|
if (ELAPSED(now, next_temp_ms)) { // Print Temp Reading every 1 second while heating up.
|
2019-05-05 03:51:47 +00:00
|
|
|
next_temp_ms = now + 1000UL;
|
|
|
|
print_heater_states(active_extruder);
|
|
|
|
#if TEMP_CHAMBER_RESIDENCY_TIME > 0
|
|
|
|
SERIAL_ECHOPGM(" W:");
|
|
|
|
if (residency_start_ms)
|
2020-04-04 00:49:45 +00:00
|
|
|
SERIAL_ECHO(long((SEC_TO_MS(TEMP_CHAMBER_RESIDENCY_TIME) - (now - residency_start_ms)) / 1000UL));
|
2019-05-05 03:51:47 +00:00
|
|
|
else
|
|
|
|
SERIAL_CHAR('?');
|
|
|
|
#endif
|
|
|
|
SERIAL_EOL();
|
|
|
|
}
|
|
|
|
|
|
|
|
idle();
|
|
|
|
gcode.reset_stepper_timeout(); // Keep steppers powered
|
|
|
|
|
|
|
|
const float temp = degChamber();
|
|
|
|
|
|
|
|
#if TEMP_CHAMBER_RESIDENCY_TIME > 0
|
|
|
|
|
|
|
|
const float temp_diff = ABS(target_temp - temp);
|
|
|
|
|
|
|
|
if (!residency_start_ms) {
|
|
|
|
// Start the TEMP_CHAMBER_RESIDENCY_TIME timer when we reach target temp for the first time.
|
2020-07-06 23:52:21 +00:00
|
|
|
if (temp_diff < TEMP_CHAMBER_WINDOW)
|
|
|
|
residency_start_ms = now + (first_loop ? SEC_TO_MS(TEMP_CHAMBER_RESIDENCY_TIME) / 3 : 0);
|
2019-05-05 03:51:47 +00:00
|
|
|
}
|
|
|
|
else if (temp_diff > TEMP_CHAMBER_HYSTERESIS) {
|
|
|
|
// Restart the timer whenever the temperature falls outside the hysteresis.
|
|
|
|
residency_start_ms = now;
|
|
|
|
}
|
|
|
|
|
2020-01-15 07:55:26 +00:00
|
|
|
first_loop = false;
|
2019-05-05 03:51:47 +00:00
|
|
|
#endif // TEMP_CHAMBER_RESIDENCY_TIME > 0
|
|
|
|
|
|
|
|
// Prevent a wait-forever situation if R is misused i.e. M191 R0
|
|
|
|
if (wants_to_cool) {
|
|
|
|
// Break after MIN_COOLING_SLOPE_TIME_CHAMBER seconds
|
|
|
|
// if the temperature did not drop at least MIN_COOLING_SLOPE_DEG_CHAMBER
|
|
|
|
if (!next_cool_check_ms || ELAPSED(now, next_cool_check_ms)) {
|
|
|
|
if (old_temp - temp < float(MIN_COOLING_SLOPE_DEG_CHAMBER)) break;
|
|
|
|
next_cool_check_ms = now + 1000UL * MIN_COOLING_SLOPE_TIME_CHAMBER;
|
|
|
|
old_temp = temp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (wait_for_heatup && TEMP_CHAMBER_CONDITIONS);
|
|
|
|
|
2020-09-12 03:51:19 +00:00
|
|
|
if (wait_for_heatup) {
|
|
|
|
wait_for_heatup = false;
|
|
|
|
ui.reset_status();
|
|
|
|
return true;
|
|
|
|
}
|
2019-05-05 03:51:47 +00:00
|
|
|
|
2020-09-12 03:51:19 +00:00
|
|
|
return false;
|
2019-05-05 03:51:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // HAS_HEATED_CHAMBER
|
|
|
|
|
2018-03-07 07:53:50 +00:00
|
|
|
#endif // HAS_TEMP_SENSOR
|