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
|
|
|
|
|
2021-01-21 09:40:07 +00:00
|
|
|
#include "../MarlinCore.h"
|
|
|
|
#include "../HAL/shared/Delay.h"
|
|
|
|
#include "../lcd/marlinui.h"
|
|
|
|
|
2011-11-15 21:50:43 +00:00
|
|
|
#include "temperature.h"
|
2018-05-09 05:17:53 +00:00
|
|
|
#include "endstops.h"
|
2017-05-04 01:43:00 +00:00
|
|
|
#include "planner.h"
|
2020-04-27 09:35:20 +00:00
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
#include "../feature/cooler.h"
|
|
|
|
#include "../feature/spindle_laser.h"
|
|
|
|
#endif
|
|
|
|
|
2021-01-21 09:40:07 +00:00
|
|
|
#if ENABLED(EMERGENCY_PARSER)
|
|
|
|
#include "motion.h"
|
|
|
|
#endif
|
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
|
|
|
|
2021-02-09 01:51:57 +00:00
|
|
|
// LIB_MAX31855 can be added to the build_flags in platformio.ini to use a user-defined library
|
|
|
|
#if LIB_USR_MAX31855
|
|
|
|
#include <Adafruit_MAX31855.h>
|
|
|
|
#if PIN_EXISTS(MAX31855_MISO) && PIN_EXISTS(MAX31855_SCK)
|
|
|
|
#define MAX31855_USES_SW_SPI 1
|
|
|
|
#endif
|
|
|
|
#if TEMP_SENSOR_0_IS_MAX31855 && PIN_EXISTS(MAX31855_CS)
|
|
|
|
#define HAS_MAX31855_TEMP 1
|
|
|
|
Adafruit_MAX31855 max31855_0 = Adafruit_MAX31855(MAX31855_CS_PIN
|
|
|
|
#if MAX31855_USES_SW_SPI
|
|
|
|
, MAX31855_MISO_PIN, MAX31855_SCK_PIN // For software SPI also set MISO/SCK
|
|
|
|
#endif
|
|
|
|
#if ENABLED(LARGE_PINMAP)
|
|
|
|
, HIGH
|
|
|
|
#endif
|
|
|
|
);
|
2020-11-11 21:52:35 +00:00
|
|
|
#endif
|
2021-02-09 01:51:57 +00:00
|
|
|
#if TEMP_SENSOR_1_IS_MAX31855 && PIN_EXISTS(MAX31855_CS2)
|
|
|
|
#define HAS_MAX31855_TEMP 1
|
|
|
|
Adafruit_MAX31855 max31855_1 = Adafruit_MAX31855(MAX31855_CS2_PIN
|
|
|
|
#if MAX31855_USES_SW_SPI
|
|
|
|
, MAX31855_MISO_PIN, MAX31855_SCK_PIN // For software SPI also set MISO/SCK
|
|
|
|
#endif
|
|
|
|
#if ENABLED(LARGE_PINMAP)
|
|
|
|
, HIGH
|
|
|
|
#endif
|
|
|
|
);
|
2019-11-21 09:15:10 +00:00
|
|
|
#endif
|
2021-02-09 01:51:57 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// LIB_MAX31865 can be added to the build_flags in platformio.ini to use a user-defined library.
|
|
|
|
// If LIB_MAX31865 is not on the build_flags then the Adafruit MAX31865 V1.1.0 library is used.
|
|
|
|
#if HAS_MAX31865
|
|
|
|
#include <Adafruit_MAX31865.h>
|
2019-11-21 09:15:10 +00:00
|
|
|
#ifndef MAX31865_MOSI_PIN
|
2021-01-01 20:31:15 +00:00
|
|
|
#define MAX31865_MOSI_PIN SD_MOSI_PIN
|
2019-11-21 09:15:10 +00:00
|
|
|
#endif
|
2021-02-09 01:51:57 +00:00
|
|
|
#if PIN_EXISTS(MAX31865_MISO) && PIN_EXISTS(MAX31865_SCK)
|
|
|
|
#define MAX31865_USES_SW_SPI 1
|
2020-11-11 21:52:35 +00:00
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_0_IS_MAX31865 && PIN_EXISTS(MAX31865_CS)
|
|
|
|
#define HAS_MAX31865_TEMP 1
|
2021-02-09 01:51:57 +00:00
|
|
|
Adafruit_MAX31865 max31865_0 = Adafruit_MAX31865(MAX31865_CS_PIN
|
|
|
|
#if MAX31865_USES_SW_SPI && PIN_EXISTS(MAX31865_MOSI)
|
|
|
|
, MAX31865_MOSI_PIN, MAX31865_MISO_PIN, MAX31865_SCK_PIN // For software SPI also set MOSI/MISO/SCK
|
|
|
|
#endif
|
|
|
|
#if ENABLED(LARGE_PINMAP)
|
|
|
|
, HIGH
|
|
|
|
#endif
|
|
|
|
);
|
2020-11-11 21:52:35 +00:00
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_1_IS_MAX31865 && PIN_EXISTS(MAX31865_CS2)
|
|
|
|
#define HAS_MAX31865_TEMP 1
|
2020-11-11 21:52:35 +00:00
|
|
|
Adafruit_MAX31865 max31865_1 = Adafruit_MAX31865(MAX31865_CS2_PIN
|
2021-02-09 01:51:57 +00:00
|
|
|
#if MAX31865_USES_SW_SPI && PIN_EXISTS(MAX31865_MOSI)
|
|
|
|
, MAX31865_MOSI_PIN, MAX31865_MISO_PIN, MAX31865_SCK_PIN // For software SPI also set MOSI/MISO/SCK
|
|
|
|
#endif
|
|
|
|
#if ENABLED(LARGE_PINMAP)
|
|
|
|
, HIGH
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// LIB_MAX6675 can be added to the build_flags in platformio.ini to use a user-defined library
|
|
|
|
#if LIB_USR_MAX6675
|
|
|
|
#include <max6675.h>
|
|
|
|
#if PIN_EXISTS(MAX6675_MISO) && PIN_EXISTS(MAX6675_SCK)
|
|
|
|
#define MAX6675_USES_SW_SPI 1
|
|
|
|
#endif
|
|
|
|
#if TEMP_SENSOR_0_IS_MAX6675 && PIN_EXISTS(MAX6675_CS)
|
|
|
|
#define HAS_MAX6675_TEMP 1
|
|
|
|
MAX6675 max6675_0 = MAX6675(MAX6675_CS_PIN
|
|
|
|
#if MAX6675_USES_SW_SPI
|
|
|
|
, MAX6675_MISO_PIN, MAX6675_SCK_PIN // For software SPI also set MISO/SCK
|
|
|
|
#endif
|
|
|
|
#if ENABLED(LARGE_PINMAP)
|
|
|
|
, HIGH
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
#endif
|
|
|
|
#if TEMP_SENSOR_1_IS_MAX6675 && PIN_EXISTS(MAX6675_CS2)
|
|
|
|
#define HAS_MAX6675_TEMP 1
|
|
|
|
MAX6675 max6675_1 = MAX6675(MAX6675_CS2_PIN
|
|
|
|
#if MAX6675_USES_SW_SPI
|
|
|
|
, MAX6675_MISO_PIN, MAX6675_SCK_PIN // For software SPI also set MISO/SCK
|
|
|
|
#endif
|
|
|
|
#if ENABLED(LARGE_PINMAP)
|
|
|
|
, HIGH
|
2020-11-11 21:52:35 +00:00
|
|
|
#endif
|
|
|
|
);
|
2019-11-21 09:15:10 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2021-02-09 01:51:57 +00:00
|
|
|
#if !HAS_MAX6675_TEMP && !HAS_MAX31855_TEMP && !HAS_MAX31865_TEMP
|
|
|
|
#define NO_THERMO_TEMPS 1
|
|
|
|
#endif
|
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
#if (TEMP_SENSOR_0_IS_MAX_TC || TEMP_SENSOR_1_IS_MAX_TC) && PINS_EXIST(MAX6675_SCK, MAX6675_DO) && NO_THERMO_TEMPS
|
|
|
|
#define THERMO_SEPARATE_SPI 1
|
2020-11-11 21:52:35 +00:00
|
|
|
#endif
|
2019-02-06 04:56:13 +00:00
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
#if THERMO_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
|
|
|
|
|
2020-10-06 23:36:01 +00:00
|
|
|
#if HAS_SERVOS
|
|
|
|
#include "./servo.h"
|
|
|
|
#endif
|
2020-11-09 07:17:37 +00:00
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
#if ANY(TEMP_SENSOR_0_IS_THERMISTOR, TEMP_SENSOR_1_IS_THERMISTOR, TEMP_SENSOR_2_IS_THERMISTOR, TEMP_SENSOR_3_IS_THERMISTOR, \
|
|
|
|
TEMP_SENSOR_4_IS_THERMISTOR, TEMP_SENSOR_5_IS_THERMISTOR, TEMP_SENSOR_6_IS_THERMISTOR, TEMP_SENSOR_7_IS_THERMISTOR )
|
2020-11-09 07:17:37 +00:00
|
|
|
#define HAS_HOTEND_THERMISTOR 1
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_HOTEND_THERMISTOR
|
2018-05-11 06:01:51 +00:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2021-02-07 22:58:06 +00:00
|
|
|
static const temp_entry_t* heater_ttbl_map[2] = { TEMPTABLE_0, TEMPTABLE_1 };
|
|
|
|
static constexpr uint8_t heater_ttbllen_map[2] = { TEMPTABLE_0_LEN, TEMPTABLE_1_LEN };
|
2018-05-11 06:01:51 +00:00
|
|
|
#else
|
2021-02-07 22:58:06 +00:00
|
|
|
#define NEXT_TEMPTABLE(N) ,TEMPTABLE_##N
|
|
|
|
#define NEXT_TEMPTABLE_LEN(N) ,TEMPTABLE_##N##_LEN
|
|
|
|
static const temp_entry_t* heater_ttbl_map[HOTENDS] = ARRAY_BY_HOTENDS(TEMPTABLE_0 REPEAT_S(1, HOTENDS, NEXT_TEMPTABLE));
|
|
|
|
static constexpr uint8_t heater_ttbllen_map[HOTENDS] = ARRAY_BY_HOTENDS(TEMPTABLE_0_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
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
#define _COOLER_PSTR(h) (h) == H_COOLER ? GET_TEXT(MSG_COOLER) :
|
|
|
|
#else
|
|
|
|
#define _COOLER_PSTR(h)
|
|
|
|
#endif
|
2019-10-10 00:46:10 +00:00
|
|
|
#define _E_PSTR(h,N) ((HOTENDS) > N && (h) == N) ? PSTR(LCD_STR_E##N) :
|
2021-03-06 20:13:28 +00:00
|
|
|
#define HEATER_PSTR(h) _BED_PSTR(h) _CHAMBER_PSTR(h) _COOLER_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 }
|
2021-03-24 09:11:43 +00:00
|
|
|
const celsius_t Temperature::hotend_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
|
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if ENABLED(AUTO_POWER_COOLER_FAN)
|
|
|
|
uint8_t Temperature::coolerfan_speed; // = 0
|
|
|
|
#endif
|
2021-03-19 21:34:10 +00:00
|
|
|
|
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)
|
|
|
|
|
2021-03-19 21:39:05 +00:00
|
|
|
Temperature::extra_fan_t Temperature::extra_fan_speed[FAN_COUNT];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handle the M106 P<fan> T<speed> command:
|
|
|
|
* T1 = Restore fan speed saved on the last T2
|
|
|
|
* T2 = Save the fan speed, then set to the last T<3-255> value
|
|
|
|
* T<3-255> = Set the "extra fan speed"
|
|
|
|
*/
|
|
|
|
void Temperature::set_temp_fan_speed(const uint8_t fan, const uint16_t command_or_speed) {
|
|
|
|
switch (command_or_speed) {
|
2019-01-12 06:41:48 +00:00
|
|
|
case 1:
|
2021-03-19 21:39:05 +00:00
|
|
|
set_fan_speed(fan, extra_fan_speed[fan].saved);
|
2019-01-12 06:41:48 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2021-03-19 21:39:05 +00:00
|
|
|
extra_fan_speed[fan].saved = fan_speed[fan];
|
|
|
|
set_fan_speed(fan, extra_fan_speed[fan].speed);
|
2019-01-12 06:41:48 +00:00
|
|
|
break;
|
|
|
|
default:
|
2021-03-19 21:39:05 +00:00
|
|
|
extra_fan_speed[fan].speed = _MIN(command_or_speed, 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;
|
2021-03-09 09:20:37 +00:00
|
|
|
PORT_REDIRECT(SerialMask::All);
|
2020-07-15 00:30:48 +00:00
|
|
|
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-09-14 04:58:39 +00:00
|
|
|
Temperature::heater_idle_t Temperature::heater_idle[NR_HEATER_IDLE]; // = { { 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
|
2021-03-24 09:11:43 +00:00
|
|
|
int16_t Temperature::mintemp_raw_BED = TEMP_SENSOR_BED_RAW_LO_TEMP,
|
|
|
|
Temperature::maxtemp_raw_BED = TEMP_SENSOR_BED_RAW_HI_TEMP;
|
2020-04-22 21:35:03 +00:00
|
|
|
TERN_(WATCH_BED, bed_watch_t Temperature::watch_bed); // = { 0 }
|
2020-11-08 00:28:29 +00:00
|
|
|
IF_DISABLED(PIDTEMPBED, millis_t Temperature::next_bed_check_ms);
|
2021-03-06 20:13:28 +00:00
|
|
|
#endif
|
2018-04-23 22:13:01 +00:00
|
|
|
|
|
|
|
#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
|
2020-10-06 23:36:01 +00:00
|
|
|
millis_t next_cool_check_ms_2 = 0;
|
|
|
|
float old_temp = 9999;
|
2021-03-24 09:11:43 +00:00
|
|
|
int16_t Temperature::mintemp_raw_CHAMBER = TEMP_SENSOR_CHAMBER_RAW_LO_TEMP,
|
|
|
|
Temperature::maxtemp_raw_CHAMBER = TEMP_SENSOR_CHAMBER_RAW_HI_TEMP;
|
2021-02-25 00:26:51 +00:00
|
|
|
TERN_(WATCH_CHAMBER, chamber_watch_t Temperature::watch_chamber{0});
|
|
|
|
IF_DISABLED(PIDTEMPCHAMBER, millis_t Temperature::next_chamber_check_ms);
|
2021-03-06 20:13:28 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_TEMP_COOLER
|
|
|
|
cooler_info_t Temperature::temp_cooler; // = { 0 }
|
|
|
|
#if HAS_COOLER
|
|
|
|
bool flag_cooler_state;
|
|
|
|
//bool flag_cooler_excess = false;
|
|
|
|
float previous_temp = 9999;
|
2021-03-24 09:11:43 +00:00
|
|
|
int16_t Temperature::mintemp_raw_COOLER = TEMP_SENSOR_COOLER_RAW_LO_TEMP,
|
|
|
|
Temperature::maxtemp_raw_COOLER = TEMP_SENSOR_COOLER_RAW_HI_TEMP;
|
2021-03-06 20:13:28 +00:00
|
|
|
#if WATCH_COOLER
|
|
|
|
cooler_watch_t Temperature::watch_cooler{0};
|
|
|
|
#endif
|
|
|
|
millis_t Temperature::next_cooler_check_ms, Temperature::cooler_fan_flush_ms;
|
|
|
|
#endif
|
|
|
|
#endif
|
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
|
|
|
|
|
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;
|
2021-03-24 09:11:43 +00:00
|
|
|
celsius_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)
|
2021-03-24 09:11:43 +00:00
|
|
|
celsius_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
|
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
#define TEMPDIR(N) ((TEMP_SENSOR_##N##_RAW_LO_TEMP) < (TEMP_SENSOR_##N##_RAW_HI_TEMP) ? 1 : -1)
|
2019-03-07 08:09:39 +00:00
|
|
|
|
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
|
2021-02-07 22:58:06 +00:00
|
|
|
constexpr temp_range_t sensor_heater_0 { TEMP_SENSOR_0_RAW_LO_TEMP, TEMP_SENSOR_0_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_1 { TEMP_SENSOR_1_RAW_LO_TEMP, TEMP_SENSOR_1_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_2 { TEMP_SENSOR_2_RAW_LO_TEMP, TEMP_SENSOR_2_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_3 { TEMP_SENSOR_3_RAW_LO_TEMP, TEMP_SENSOR_3_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_4 { TEMP_SENSOR_4_RAW_LO_TEMP, TEMP_SENSOR_4_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_5 { TEMP_SENSOR_5_RAW_LO_TEMP, TEMP_SENSOR_5_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_6 { TEMP_SENSOR_6_RAW_LO_TEMP, TEMP_SENSOR_6_RAW_HI_TEMP, 0, 16383 },
|
|
|
|
sensor_heater_7 { TEMP_SENSOR_7_RAW_LO_TEMP, TEMP_SENSOR_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
|
|
|
|
|
2021-01-20 02:58:50 +00:00
|
|
|
#if ENABLED(SINGLENOZZLE_STANDBY_TEMP)
|
2021-03-24 09:11:43 +00:00
|
|
|
celsius_t Temperature::singlenozzle_temp[EXTRUDERS];
|
2021-01-20 02:58:50 +00:00
|
|
|
#if HAS_FAN
|
|
|
|
uint8_t Temperature::singlenozzle_fan_speed[EXTRUDERS];
|
|
|
|
#endif
|
|
|
|
#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
|
|
|
|
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);
|
2021-02-25 00:26:51 +00:00
|
|
|
const bool ischamber = (heater_id == H_CHAMBER);
|
2019-06-26 05:40:29 +00:00
|
|
|
|
2021-02-25 00:26:51 +00:00
|
|
|
#if ENABLED(PIDTEMPCHAMBER)
|
|
|
|
#define C_TERN(T,A,B) ((T) ? (A) : (B))
|
2018-01-04 03:30:45 +00:00
|
|
|
#else
|
2021-02-25 00:26:51 +00:00
|
|
|
#define C_TERN(T,A,B) (B)
|
2018-01-04 03:30:45 +00:00
|
|
|
#endif
|
2021-02-25 00:26:51 +00:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
|
|
|
#define B_TERN(T,A,B) ((T) ? (A) : (B))
|
|
|
|
#else
|
|
|
|
#define B_TERN(T,A,B) (B)
|
|
|
|
#endif
|
|
|
|
#define GHV(C,B,H) C_TERN(ischamber, C, B_TERN(isbed, B, H))
|
|
|
|
#define SHV(V) C_TERN(ischamber, temp_chamber.soft_pwm_amount = V, B_TERN(isbed, temp_bed.soft_pwm_amount = V, temp_hotend[heater_id].soft_pwm_amount = V))
|
|
|
|
#define ONHEATINGSTART() C_TERN(ischamber, printerEventLEDs.onChamberHeatingStart(), B_TERN(isbed, printerEventLEDs.onBedHeatingStart(), printerEventLEDs.onHotendHeatingStart()))
|
|
|
|
#define ONHEATING(S,C,T) C_TERN(ischamber, printerEventLEDs.onChamberHeating(S,C,T), B_TERN(isbed, printerEventLEDs.onBedHeating(S,C,T), printerEventLEDs.onHotendHeating(S,C,T)))
|
|
|
|
|
|
|
|
#define WATCH_PID BOTH(WATCH_CHAMBER, PIDTEMPCHAMBER) || 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
|
2021-02-25 00:26:51 +00:00
|
|
|
#if BOTH(THERMAL_PROTECTION_CHAMBER, PIDTEMPCHAMBER)
|
|
|
|
#define C_GTV(T,A,B) ((T) ? (A) : (B))
|
2020-05-18 18:51:32 +00:00
|
|
|
#else
|
2021-02-25 00:26:51 +00:00
|
|
|
#define C_GTV(T,A,B) (B)
|
2018-07-15 21:07:31 +00:00
|
|
|
#endif
|
2021-02-25 00:26:51 +00:00
|
|
|
#if BOTH(THERMAL_PROTECTION_BED, PIDTEMPBED)
|
|
|
|
#define B_GTV(T,A,B) ((T) ? (A) : (B))
|
|
|
|
#else
|
|
|
|
#define B_GTV(T,A,B) (B)
|
|
|
|
#endif
|
|
|
|
#define GTV(C,B,H) C_GTV(ischamber, C, B_GTV(isbed, B, H))
|
|
|
|
const uint16_t watch_temp_period = GTV(WATCH_CHAMBER_TEMP_PERIOD, WATCH_BED_TEMP_PERIOD, WATCH_TEMP_PERIOD);
|
|
|
|
const uint8_t watch_temp_increase = GTV(WATCH_CHAMBER_TEMP_INCREASE, WATCH_BED_TEMP_INCREASE, WATCH_TEMP_INCREASE);
|
|
|
|
const float watch_temp_target = target - float(watch_temp_increase + GTV(TEMP_CHAMBER_HYSTERESIS, 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
|
|
|
|
2021-03-19 21:34:10 +00:00
|
|
|
if (target > GHV(CHAMBER_MAX_TARGET, 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
|
|
|
|
2021-02-25 00:26:51 +00:00
|
|
|
long bias = GHV(MAX_CHAMBER_POWER, MAX_BED_POWER, PID_MAX) >> 1, d = bias;
|
|
|
|
SHV(bias);
|
2012-09-13 02:01:31 +00:00
|
|
|
|
2018-10-11 02:25:43 +00:00
|
|
|
#if ENABLED(PRINTER_EVENT_LEDS)
|
2021-02-25 00:26:51 +00:00
|
|
|
const float start_temp = GHV(temp_chamber.celsius, 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
|
2021-02-25 00:26:51 +00:00
|
|
|
current_temp = GHV(temp_chamber.celsius, 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
|
|
|
|
|
2021-02-25 00:26:51 +00:00
|
|
|
if (heating && current_temp > target && ELAPSED(ms, t2 + 5000UL)) {
|
|
|
|
heating = false;
|
|
|
|
SHV((bias - d) >> 1);
|
|
|
|
t1 = ms;
|
|
|
|
t_high = t1 - t2;
|
|
|
|
maxT = target;
|
2012-03-08 20:43:21 +00:00
|
|
|
}
|
2015-05-13 09:02:19 +00:00
|
|
|
|
2021-02-25 00:26:51 +00:00
|
|
|
if (!heating && current_temp < target && ELAPSED(ms, t1 + 5000UL)) {
|
|
|
|
heating = true;
|
|
|
|
t2 = ms;
|
|
|
|
t_low = t2 - t1;
|
|
|
|
if (cycles > 0) {
|
|
|
|
const long max_pow = GHV(MAX_CHAMBER_POWER, MAX_BED_POWER, PID_MAX);
|
|
|
|
bias += (d * (t_high - t_low)) / (t_low + t_high);
|
|
|
|
LIMIT(bias, 20, max_pow - 20);
|
|
|
|
d = (bias > max_pow >> 1) ? max_pow - 1 - bias : bias;
|
|
|
|
|
|
|
|
SERIAL_ECHOPAIR(STR_BIAS, bias, STR_D_COLON, d, STR_T_MIN, minT, STR_T_MAX, maxT);
|
|
|
|
if (cycles > 2) {
|
|
|
|
const float Ku = (4.0f * d) / (float(M_PI) * (maxT - minT) * 0.5f),
|
|
|
|
Tu = float(t_low + t_high) * 0.001f,
|
|
|
|
pf = ischamber ? 0.2f : (isbed ? 0.2f : 0.6f),
|
|
|
|
df = ischamber ? 1.0f / 3.0f : (isbed ? 1.0f / 3.0f : 1.0f / 8.0f);
|
|
|
|
|
|
|
|
tune_pid.Kp = Ku * pf;
|
|
|
|
tune_pid.Ki = tune_pid.Kp * 2.0f / Tu;
|
|
|
|
tune_pid.Kd = tune_pid.Kp * Tu * df;
|
|
|
|
|
|
|
|
SERIAL_ECHOLNPAIR(STR_KU, Ku, STR_TU, Tu);
|
|
|
|
if (ischamber || isbed)
|
|
|
|
SERIAL_ECHOLNPGM(" No overshoot");
|
|
|
|
else
|
|
|
|
SERIAL_ECHOLNPGM(STR_CLASSIC_PID);
|
|
|
|
SERIAL_ECHOLNPAIR(STR_KP, tune_pid.Kp, STR_KI, tune_pid.Ki, STR_KD, tune_pid.Kd);
|
2012-03-08 20:43:21 +00:00
|
|
|
}
|
|
|
|
}
|
2021-02-25 00:26:51 +00:00
|
|
|
SHV((bias + d) >> 1);
|
|
|
|
cycles++;
|
|
|
|
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
|
2021-02-25 00:26:51 +00:00
|
|
|
print_heater_states(ischamber ? active_extruder : (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
|
2021-02-25 00:26:51 +00:00
|
|
|
if (BOTH(WATCH_BED, WATCH_HOTENDS) || isbed == DISABLED(WATCH_HOTENDS) || ischamber == DISABLED(WATCH_HOTENDS)) {
|
2020-04-01 23:53:58 +00:00
|
|
|
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-09-17 10:35:04 +00:00
|
|
|
TERN_(DWIN_CREALITY_LCD, DWIN_Popup_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
|
|
|
|
2021-02-25 00:26:51 +00:00
|
|
|
#if EITHER(PIDTEMPBED, PIDTEMPCHAMBER)
|
|
|
|
PGM_P const estring = GHV(PSTR("chamber"), PSTR("bed"), NUL_STR);
|
2021-03-01 01:43:46 +00:00
|
|
|
say_default_(); SERIAL_ECHOPGM_P(estring); SERIAL_ECHOLNPAIR("Kp ", tune_pid.Kp);
|
|
|
|
say_default_(); SERIAL_ECHOPGM_P(estring); SERIAL_ECHOLNPAIR("Ki ", tune_pid.Ki);
|
|
|
|
say_default_(); SERIAL_ECHOPGM_P(estring); SERIAL_ECHOLNPAIR("Kd ", tune_pid.Kd);
|
2021-02-25 00:26:51 +00:00
|
|
|
#else
|
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
|
|
|
#endif
|
|
|
|
|
2021-02-25 00:26:51 +00:00
|
|
|
auto _set_hotend_pid = [](const uint8_t e, const PID_t &in_pid) {
|
|
|
|
#if ENABLED(PIDTEMP)
|
|
|
|
PID_PARAM(Kp, e) = in_pid.Kp;
|
|
|
|
PID_PARAM(Ki, e) = scalePID_i(in_pid.Ki);
|
|
|
|
PID_PARAM(Kd, e) = scalePID_d(in_pid.Kd);
|
|
|
|
updatePID();
|
|
|
|
#else
|
|
|
|
UNUSED(e); UNUSED(in_pid);
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
#if ENABLED(PIDTEMPBED)
|
|
|
|
auto _set_bed_pid = [](const PID_t &in_pid) {
|
|
|
|
temp_bed.pid.Kp = in_pid.Kp;
|
|
|
|
temp_bed.pid.Ki = scalePID_i(in_pid.Ki);
|
|
|
|
temp_bed.pid.Kd = scalePID_d(in_pid.Kd);
|
|
|
|
};
|
|
|
|
#endif
|
2016-04-20 01:09:29 +00:00
|
|
|
|
2021-02-25 00:26:51 +00:00
|
|
|
#if ENABLED(PIDTEMPCHAMBER)
|
|
|
|
auto _set_chamber_pid = [](const PID_t &in_pid) {
|
|
|
|
temp_chamber.pid.Kp = in_pid.Kp;
|
|
|
|
temp_chamber.pid.Ki = scalePID_i(in_pid.Ki);
|
|
|
|
temp_chamber.pid.Kd = scalePID_d(in_pid.Kd);
|
|
|
|
};
|
|
|
|
#endif
|
2016-04-19 02:02:11 +00:00
|
|
|
|
|
|
|
// Use the result? (As with "M303 U1")
|
2021-02-25 00:26:51 +00:00
|
|
|
if (set_result)
|
|
|
|
GHV(_set_chamber_pid(tune_pid), _set_bed_pid(tune_pid), _set_hotend_pid(heater_id, tune_pid));
|
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-10-10 04:35:41 +00:00
|
|
|
|
|
|
|
// Run HAL idle tasks
|
|
|
|
TERN_(HAL_IDLETASK, HAL_idletask());
|
|
|
|
|
|
|
|
// Run UI update
|
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
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
case H_COOLER: return temp_cooler.soft_pwm_amount;
|
|
|
|
#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
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_AUTO_COOLER_FAN
|
|
|
|
if (temp_cooler.celsius >= COOLER_AUTO_FAN_TEMPERATURE)
|
|
|
|
SBI(fanState, pgm_read_byte(&fanBit[COOLER_FAN_INDEX]));
|
|
|
|
#endif
|
|
|
|
|
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
|
2021-01-04 03:39:15 +00:00
|
|
|
thermalManager.disable_all_heaters();
|
2019-07-10 02:35:07 +00:00
|
|
|
for (uint8_t i = 20; i--;) {
|
2021-01-04 03:39:15 +00:00
|
|
|
WRITE(BEEPER_PIN, HIGH);
|
|
|
|
delay(25);
|
|
|
|
watchdog_refresh();
|
|
|
|
WRITE(BEEPER_PIN, LOW);
|
|
|
|
delay(40);
|
|
|
|
watchdog_refresh();
|
|
|
|
delay(40);
|
|
|
|
watchdog_refresh();
|
2019-07-10 02:35:07 +00:00
|
|
|
}
|
|
|
|
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();
|
2021-03-01 01:43:46 +00:00
|
|
|
SERIAL_ECHOPGM_P(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)
|
2021-02-08 06:37:24 +00:00
|
|
|
SERIAL_ECHO(heater_id);
|
2020-09-13 23:06:14 +00:00
|
|
|
else if (TERN0(HAS_HEATED_CHAMBER, heater_id == H_CHAMBER))
|
2020-04-22 21:35:03 +00:00
|
|
|
SERIAL_ECHOPGM(STR_HEATER_CHAMBER);
|
2021-03-06 20:13:28 +00:00
|
|
|
else if (TERN0(HAS_COOLER, heater_id == H_COOLER))
|
|
|
|
SERIAL_ECHOPGM(STR_COOLER);
|
2020-04-22 21:35:03 +00:00
|
|
|
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)
|
2021-01-04 03:39:15 +00:00
|
|
|
watchdog_refresh();
|
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-09-17 10:35:04 +00:00
|
|
|
#if ENABLED(DWIN_CREALITY_LCD) && (HAS_HOTEND || HAS_HEATED_BED)
|
|
|
|
DWIN_Popup_Temperature(1);
|
|
|
|
#endif
|
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-09-17 10:35:04 +00:00
|
|
|
#if ENABLED(DWIN_CREALITY_LCD) && (HAS_HOTEND || HAS_HEATED_BED)
|
|
|
|
DWIN_Popup_Temperature(0);
|
|
|
|
#endif
|
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
|
|
|
}
|
|
|
|
|
2021-02-25 00:26:51 +00:00
|
|
|
#if ANY(PID_DEBUG, PID_BED_DEBUG, PID_CHAMBER_DEBUG)
|
|
|
|
bool Temperature::pid_debug_flag; // = 0
|
|
|
|
#endif
|
|
|
|
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_HOTEND
|
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-09-14 04:58:39 +00:00
|
|
|
|| TERN0(HEATER_IDLE_HANDLER, heater_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)
|
2021-01-04 03:39:15 +00:00
|
|
|
if (fan_speed[active_extruder] > PID_FAN_SCALING_MIN_SPEED) {
|
|
|
|
work_pid[ee].Kf = PID_PARAM(Kf, ee) + (PID_FAN_SCALING_LIN_FACTOR) * fan_speed[active_extruder];
|
2019-11-26 09:34:43 +00:00
|
|
|
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) {
|
2021-02-25 00:26:51 +00:00
|
|
|
SERIAL_ECHO_MSG(STR_PID_DEBUG, ee, STR_PID_DEBUG_INPUT, temp_hotend[ee].celsius, STR_PID_DEBUG_OUTPUT, pid_output
|
|
|
|
#if DISABLED(PID_OPENLOOP)
|
|
|
|
, 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
|
2021-02-25 00:26:51 +00:00
|
|
|
#endif
|
|
|
|
);
|
2019-09-10 07:20:49 +00:00
|
|
|
}
|
2021-02-25 00:26:51 +00:00
|
|
|
#endif
|
2015-03-14 02:49:41 +00:00
|
|
|
|
2019-09-10 07:20:49 +00:00
|
|
|
#else // No PID enabled
|
|
|
|
|
2020-09-14 04:58:39 +00:00
|
|
|
const bool is_idling = TERN0(HEATER_IDLE_HANDLER, heater_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)
|
2021-02-25 00:26:51 +00:00
|
|
|
if (pid_debug_flag) {
|
|
|
|
SERIAL_ECHO_MSG(
|
|
|
|
" PID_BED_DEBUG : Input ", temp_bed.celsius, " Output ", pid_output
|
|
|
|
#if DISABLED(PID_OPENLOOP)
|
|
|
|
, STR_PID_DEBUG_PTERM, work_pid.Kp
|
|
|
|
, STR_PID_DEBUG_ITERM, work_pid.Ki
|
|
|
|
, STR_PID_DEBUG_DTERM, work_pid.Kd
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return pid_output;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // PIDTEMPBED
|
|
|
|
|
|
|
|
#if ENABLED(PIDTEMPCHAMBER)
|
|
|
|
|
|
|
|
float Temperature::get_pid_output_chamber() {
|
|
|
|
|
|
|
|
#if DISABLED(PID_OPENLOOP)
|
|
|
|
|
|
|
|
static PID_t work_pid{0};
|
|
|
|
static float temp_iState = 0, temp_dState = 0;
|
|
|
|
static bool pid_reset = true;
|
|
|
|
float pid_output = 0;
|
|
|
|
const float max_power_over_i_gain = float(MAX_CHAMBER_POWER) / temp_chamber.pid.Ki - float(MIN_CHAMBER_POWER),
|
|
|
|
pid_error = temp_chamber.target - temp_chamber.celsius;
|
|
|
|
|
|
|
|
if (!temp_chamber.target || pid_error < -(PID_FUNCTIONAL_RANGE)) {
|
|
|
|
pid_output = 0;
|
|
|
|
pid_reset = true;
|
|
|
|
}
|
|
|
|
else if (pid_error > PID_FUNCTIONAL_RANGE) {
|
|
|
|
pid_output = MAX_CHAMBER_POWER;
|
|
|
|
pid_reset = true;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (pid_reset) {
|
|
|
|
temp_iState = 0.0;
|
|
|
|
work_pid.Kd = 0.0;
|
|
|
|
pid_reset = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
temp_iState = constrain(temp_iState + pid_error, 0, max_power_over_i_gain);
|
|
|
|
|
|
|
|
work_pid.Kp = temp_chamber.pid.Kp * pid_error;
|
|
|
|
work_pid.Ki = temp_chamber.pid.Ki * temp_iState;
|
|
|
|
work_pid.Kd = work_pid.Kd + PID_K2 * (temp_chamber.pid.Kd * (temp_dState - temp_chamber.celsius) - work_pid.Kd);
|
|
|
|
|
|
|
|
temp_dState = temp_chamber.celsius;
|
|
|
|
|
|
|
|
pid_output = constrain(work_pid.Kp + work_pid.Ki + work_pid.Kd + float(MIN_CHAMBER_POWER), 0, MAX_CHAMBER_POWER);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else // PID_OPENLOOP
|
|
|
|
|
|
|
|
const float pid_output = constrain(temp_chamber.target, 0, MAX_CHAMBER_POWER);
|
|
|
|
|
|
|
|
#endif // PID_OPENLOOP
|
|
|
|
|
|
|
|
#if ENABLED(PID_CHAMBER_DEBUG)
|
2019-10-01 02:44:07 +00:00
|
|
|
{
|
2021-02-05 05:22:42 +00:00
|
|
|
SERIAL_ECHO_MSG(
|
2021-02-25 00:26:51 +00:00
|
|
|
" PID_CHAMBER_DEBUG : Input ", temp_chamber.celsius, " Output ", pid_output
|
2019-03-05 12:46:19 +00:00
|
|
|
#if DISABLED(PID_OPENLOOP)
|
2021-02-25 00:26:51 +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
|
|
|
|
2021-02-25 00:26:51 +00:00
|
|
|
#endif // PIDTEMPCHAMBER
|
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-10-16 21:11:00 +00:00
|
|
|
#if ENABLED(EMERGENCY_PARSER)
|
|
|
|
if (emergency_parser.killed_by_M112) kill(M112_KILL_STR, nullptr, true);
|
|
|
|
|
|
|
|
if (emergency_parser.quickstop_by_M410) {
|
|
|
|
emergency_parser.quickstop_by_M410 = false; // quickstop_stepper may call idle so clear this now!
|
|
|
|
quickstop_stepper();
|
|
|
|
}
|
|
|
|
#endif
|
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)
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_0_IS_MAX_TC
|
|
|
|
if (temp_hotend[0].celsius > _MIN(HEATER_0_MAXTEMP, TEMP_SENSOR_0_MAX_TC_TMAX - 1.0)) max_temp_error(H_E0);
|
|
|
|
if (temp_hotend[0].celsius < _MAX(HEATER_0_MINTEMP, TEMP_SENSOR_0_MAX_TC_TMIN + .01)) min_temp_error(H_E0);
|
2020-07-11 05:23:48 +00:00
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_1_IS_MAX_TC
|
|
|
|
if (temp_hotend[1].celsius > _MIN(HEATER_1_MAXTEMP, TEMP_SENSOR_1_MAX_TC_TMAX - 1.0)) max_temp_error(H_E1);
|
|
|
|
if (temp_hotend[1].celsius < _MAX(HEATER_1_MINTEMP, TEMP_SENSOR_1_MAX_TC_TMIN + .01)) min_temp_error(H_E1);
|
2020-07-11 05:23:48 +00:00
|
|
|
#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)
|
2020-09-14 04:58:39 +00:00
|
|
|
if (degHotend(e) > temp_range[e].maxtemp) max_temp_error((heater_id_t)e);
|
2019-09-10 07:20:49 +00:00
|
|
|
#endif
|
2017-05-26 18:01:02 +00:00
|
|
|
|
2020-09-14 04:58:39 +00:00
|
|
|
TERN_(HEATER_IDLE_HANDLER, heater_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-14 04:58:39 +00:00
|
|
|
tr_state_machine[e].run(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?
|
2020-09-17 10:35:04 +00:00
|
|
|
TERN_(DWIN_CREALITY_LCD, DWIN_Popup_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)
|
2020-09-14 04:58:39 +00:00
|
|
|
if (degBed() > BED_MAXTEMP) max_temp_error(H_BED);
|
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?
|
2020-09-17 10:35:04 +00:00
|
|
|
TERN_(DWIN_CREALITY_LCD, DWIN_Popup_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-09-14 04:58:39 +00:00
|
|
|
TERN_(HEATER_IDLE_HANDLER, heater_idle[IDLE_INDEX_BED].update(ms));
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2020-09-14 04:58:39 +00:00
|
|
|
#if HAS_THERMALLY_PROTECTED_BED
|
|
|
|
tr_state_machine[RUNAWAY_IND_BED].run(temp_bed.celsius, temp_bed.target, H_BED, THERMAL_PROTECTION_BED_PERIOD, THERMAL_PROTECTION_BED_HYSTERESIS);
|
|
|
|
#endif
|
2014-06-30 18:22:37 +00:00
|
|
|
|
2019-05-07 00:55:01 +00:00
|
|
|
#if HEATER_IDLE_HANDLER
|
2020-09-14 04:58:39 +00:00
|
|
|
if (heater_idle[IDLE_INDEX_BED].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)
|
2020-09-14 04:58:39 +00:00
|
|
|
if (degChamber() > CHAMBER_MAXTEMP) max_temp_error(H_CHAMBER);
|
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
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if EITHER(CHAMBER_FAN, CHAMBER_VENT) || DISABLED(PIDTEMPCHAMBER)
|
|
|
|
static bool flag_chamber_excess_heat; // = false;
|
|
|
|
#endif
|
|
|
|
|
2020-10-06 23:36:01 +00:00
|
|
|
#if EITHER(CHAMBER_FAN, CHAMBER_VENT)
|
2021-03-06 20:13:28 +00:00
|
|
|
static bool flag_chamber_off; // = false
|
|
|
|
|
2020-10-06 23:36:01 +00:00
|
|
|
if (temp_chamber.target > CHAMBER_MINTEMP) {
|
|
|
|
flag_chamber_off = false;
|
|
|
|
|
|
|
|
#if ENABLED(CHAMBER_FAN)
|
2021-03-06 20:13:28 +00:00
|
|
|
int16_t fan_chamber_pwm;
|
2020-10-06 23:36:01 +00:00
|
|
|
#if CHAMBER_FAN_MODE == 0
|
2021-01-01 20:56:59 +00:00
|
|
|
fan_chamber_pwm = CHAMBER_FAN_BASE;
|
2020-10-06 23:36:01 +00:00
|
|
|
#elif CHAMBER_FAN_MODE == 1
|
2020-10-07 00:42:03 +00:00
|
|
|
fan_chamber_pwm = (temp_chamber.celsius > temp_chamber.target) ? (CHAMBER_FAN_BASE) + (CHAMBER_FAN_FACTOR) * (temp_chamber.celsius - temp_chamber.target) : 0;
|
2020-10-06 23:36:01 +00:00
|
|
|
#elif CHAMBER_FAN_MODE == 2
|
|
|
|
fan_chamber_pwm = (CHAMBER_FAN_BASE) + (CHAMBER_FAN_FACTOR) * ABS(temp_chamber.celsius - temp_chamber.target);
|
|
|
|
if (temp_chamber.soft_pwm_amount)
|
|
|
|
fan_chamber_pwm += (CHAMBER_FAN_FACTOR) * 2;
|
|
|
|
#endif
|
2020-10-07 00:42:03 +00:00
|
|
|
NOMORE(fan_chamber_pwm, 225);
|
2021-01-04 03:39:15 +00:00
|
|
|
set_fan_speed(2, fan_chamber_pwm); // TODO: instead of fan 2, set to chamber fan
|
2020-10-06 23:36:01 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(CHAMBER_VENT)
|
|
|
|
#ifndef MIN_COOLING_SLOPE_TIME_CHAMBER_VENT
|
|
|
|
#define MIN_COOLING_SLOPE_TIME_CHAMBER_VENT 20
|
|
|
|
#endif
|
|
|
|
#ifndef MIN_COOLING_SLOPE_DEG_CHAMBER_VENT
|
|
|
|
#define MIN_COOLING_SLOPE_DEG_CHAMBER_VENT 1.5
|
|
|
|
#endif
|
2020-10-29 06:14:02 +00:00
|
|
|
if (!flag_chamber_excess_heat && temp_chamber.celsius - temp_chamber.target >= HIGH_EXCESS_HEAT_LIMIT) {
|
|
|
|
// Open vent after MIN_COOLING_SLOPE_TIME_CHAMBER_VENT seconds if the
|
|
|
|
// temperature didn't drop at least MIN_COOLING_SLOPE_DEG_CHAMBER_VENT
|
2020-10-06 23:36:01 +00:00
|
|
|
if (next_cool_check_ms_2 == 0 || ELAPSED(ms, next_cool_check_ms_2)) {
|
2021-03-06 20:13:28 +00:00
|
|
|
if (temp_chamber.celsius - old_temp > MIN_COOLING_SLOPE_DEG_CHAMBER_VENT)
|
|
|
|
flag_chamber_excess_heat = true; // the bed is heating the chamber too much
|
2021-01-29 02:40:20 +00:00
|
|
|
next_cool_check_ms_2 = ms + SEC_TO_MS(MIN_COOLING_SLOPE_TIME_CHAMBER_VENT);
|
2020-10-06 23:36:01 +00:00
|
|
|
old_temp = temp_chamber.celsius;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
next_cool_check_ms_2 = 0;
|
|
|
|
old_temp = 9999;
|
|
|
|
}
|
2021-03-06 20:13:28 +00:00
|
|
|
if (flag_chamber_excess_heat && (temp_chamber.target - temp_chamber.celsius >= LOW_EXCESS_HEAT_LIMIT))
|
2020-10-06 23:36:01 +00:00
|
|
|
flag_chamber_excess_heat = false;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else if (!flag_chamber_off) {
|
|
|
|
#if ENABLED(CHAMBER_FAN)
|
|
|
|
flag_chamber_off = true;
|
2021-01-04 03:39:15 +00:00
|
|
|
set_fan_speed(2, 0);
|
2020-10-06 23:36:01 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(CHAMBER_VENT)
|
|
|
|
flag_chamber_excess_heat = false;
|
|
|
|
MOVE_SERVO(CHAMBER_VENT_SERVO_NR, 90);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2021-02-25 00:26:51 +00:00
|
|
|
#if ENABLED(PIDTEMPCHAMBER)
|
|
|
|
// PIDTEMPCHAMBER doens't support a CHAMBER_VENT yet.
|
|
|
|
temp_chamber.soft_pwm_amount = WITHIN(temp_chamber.celsius, CHAMBER_MINTEMP, CHAMBER_MAXTEMP) ? (int)get_pid_output_chamber() >> 1 : 0;
|
|
|
|
#else
|
2021-03-06 20:13:28 +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
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
if (WITHIN(temp_chamber.celsius, CHAMBER_MINTEMP, CHAMBER_MAXTEMP)) {
|
2021-02-25 00:26:51 +00:00
|
|
|
if (flag_chamber_excess_heat) {
|
|
|
|
temp_chamber.soft_pwm_amount = 0;
|
|
|
|
#if ENABLED(CHAMBER_VENT)
|
|
|
|
if (!flag_chamber_off) MOVE_SERVO(CHAMBER_VENT_SERVO_NR, temp_chamber.celsius <= temp_chamber.target ? 0 : 90);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
#if ENABLED(CHAMBER_LIMIT_SWITCHING)
|
|
|
|
if (temp_chamber.celsius >= temp_chamber.target + TEMP_CHAMBER_HYSTERESIS)
|
|
|
|
temp_chamber.soft_pwm_amount = 0;
|
|
|
|
else if (temp_chamber.celsius <= temp_chamber.target - (TEMP_CHAMBER_HYSTERESIS))
|
|
|
|
temp_chamber.soft_pwm_amount = (MAX_CHAMBER_POWER) >> 1;
|
|
|
|
#else
|
|
|
|
temp_chamber.soft_pwm_amount = temp_chamber.celsius < temp_chamber.target ? (MAX_CHAMBER_POWER) >> 1 : 0;
|
|
|
|
#endif
|
|
|
|
#if ENABLED(CHAMBER_VENT)
|
|
|
|
if (!flag_chamber_off) MOVE_SERVO(CHAMBER_VENT_SERVO_NR, 0);
|
|
|
|
#endif
|
|
|
|
}
|
2020-10-07 00:42:03 +00:00
|
|
|
}
|
|
|
|
else {
|
2021-02-25 00:26:51 +00:00
|
|
|
temp_chamber.soft_pwm_amount = 0;
|
|
|
|
WRITE_HEATER_CHAMBER(LOW);
|
2020-10-06 23:36:01 +00:00
|
|
|
}
|
2021-02-25 00:26:51 +00:00
|
|
|
}
|
|
|
|
#if ENABLED(THERMAL_PROTECTION_CHAMBER)
|
|
|
|
tr_state_machine[RUNAWAY_IND_CHAMBER].run(temp_chamber.celsius, temp_chamber.target, H_CHAMBER, THERMAL_PROTECTION_CHAMBER_PERIOD, THERMAL_PROTECTION_CHAMBER_HYSTERESIS);
|
|
|
|
#endif
|
|
|
|
#endif
|
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
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
|
|
|
|
#ifndef COOLER_CHECK_INTERVAL
|
|
|
|
#define COOLER_CHECK_INTERVAL 2000UL
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(THERMAL_PROTECTION_COOLER)
|
|
|
|
if (degCooler() > COOLER_MAXTEMP) max_temp_error(H_COOLER);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if WATCH_COOLER
|
|
|
|
// Make sure temperature is decreasing
|
|
|
|
if (watch_cooler.elapsed(ms)) { // Time to check the cooler?
|
|
|
|
if (degCooler() > watch_cooler.target) // Failed to decrease enough?
|
|
|
|
_temp_error(H_COOLER, GET_TEXT(MSG_COOLING_FAILED), GET_TEXT(MSG_COOLING_FAILED));
|
|
|
|
else
|
|
|
|
start_watching_cooler(); // Start again if the target is still far off
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static bool flag_cooler_state; // = false
|
|
|
|
|
|
|
|
if (cooler.is_enabled()) {
|
|
|
|
flag_cooler_state = true; // used to allow M106 fan control when cooler is disabled
|
2021-03-19 21:34:10 +00:00
|
|
|
if (temp_cooler.target == 0) temp_cooler.target = COOLER_MIN_TARGET;
|
2021-03-06 20:13:28 +00:00
|
|
|
if (ELAPSED(ms, next_cooler_check_ms)) {
|
|
|
|
next_cooler_check_ms = ms + COOLER_CHECK_INTERVAL;
|
|
|
|
if (temp_cooler.celsius > temp_cooler.target) {
|
|
|
|
temp_cooler.soft_pwm_amount = temp_cooler.celsius > temp_cooler.target ? MAX_COOLER_POWER : 0;
|
|
|
|
flag_cooler_state = temp_cooler.soft_pwm_amount > 0 ? true : false; // used to allow M106 fan control when cooler is disabled
|
|
|
|
#if ENABLED(COOLER_FAN)
|
|
|
|
int16_t fan_cooler_pwm = (COOLER_FAN_BASE) + (COOLER_FAN_FACTOR) * ABS(temp_cooler.celsius - temp_cooler.target);
|
|
|
|
NOMORE(fan_cooler_pwm, 255);
|
|
|
|
set_fan_speed(COOLER_FAN_INDEX, fan_cooler_pwm); // Set cooler fan pwm
|
|
|
|
cooler_fan_flush_ms = ms + 5000;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
temp_cooler.soft_pwm_amount = 0;
|
|
|
|
#if ENABLED(COOLER_FAN)
|
|
|
|
set_fan_speed(COOLER_FAN_INDEX, temp_cooler.celsius > temp_cooler.target - 2 ? COOLER_FAN_BASE : 0);
|
|
|
|
#endif
|
|
|
|
WRITE_HEATER_COOLER(LOW);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
temp_cooler.soft_pwm_amount = 0;
|
|
|
|
if (flag_cooler_state) {
|
|
|
|
flag_cooler_state = false;
|
|
|
|
thermalManager.set_fan_speed(COOLER_FAN_INDEX, 0);
|
|
|
|
}
|
|
|
|
WRITE_HEATER_COOLER(LOW);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ENABLED(THERMAL_PROTECTION_COOLER)
|
|
|
|
tr_state_machine[RUNAWAY_IND_COOLER].run(temp_cooler.celsius, temp_cooler.target, H_COOLER, THERMAL_PROTECTION_COOLER_PERIOD, THERMAL_PROTECTION_COOLER_HYSTERESIS);
|
|
|
|
#endif
|
|
|
|
#endif // HAS_COOLER
|
|
|
|
|
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.
|
|
|
|
*/
|
2021-03-24 09:11:43 +00:00
|
|
|
#define SCAN_THERMISTOR_TABLE(TBL,LEN) do{ \
|
|
|
|
uint8_t l = 0, r = LEN, m; \
|
|
|
|
for (;;) { \
|
|
|
|
m = (l + r) >> 1; \
|
|
|
|
if (!m) return celsius_t(pgm_read_word(&TBL[0].celsius)); \
|
|
|
|
if (m == l || m == r) return celsius_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 celsius_t v01 = celsius_t(pgm_read_word(&TBL[m-1].celsius)), \
|
|
|
|
v11 = celsius_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() {
|
2021-01-04 03:39:15 +00:00
|
|
|
user_thermistor_t default_user_thermistor[USER_THERMISTORS] = {
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_0_IS_CUSTOM
|
2019-05-06 23:51:06 +00:00
|
|
|
{ true, 0, 0, HOTEND0_PULLUP_RESISTOR_OHMS, HOTEND0_RESISTANCE_25C_OHMS, 0, 0, HOTEND0_BETA, 0 },
|
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_1_IS_CUSTOM
|
2019-05-06 23:51:06 +00:00
|
|
|
{ true, 0, 0, HOTEND1_PULLUP_RESISTOR_OHMS, HOTEND1_RESISTANCE_25C_OHMS, 0, 0, HOTEND1_BETA, 0 },
|
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_2_IS_CUSTOM
|
2019-05-06 23:51:06 +00:00
|
|
|
{ true, 0, 0, HOTEND2_PULLUP_RESISTOR_OHMS, HOTEND2_RESISTANCE_25C_OHMS, 0, 0, HOTEND2_BETA, 0 },
|
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_3_IS_CUSTOM
|
2019-05-06 23:51:06 +00:00
|
|
|
{ true, 0, 0, HOTEND3_PULLUP_RESISTOR_OHMS, HOTEND3_RESISTANCE_25C_OHMS, 0, 0, HOTEND3_BETA, 0 },
|
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_4_IS_CUSTOM
|
2019-05-06 23:51:06 +00:00
|
|
|
{ true, 0, 0, HOTEND4_PULLUP_RESISTOR_OHMS, HOTEND4_RESISTANCE_25C_OHMS, 0, 0, HOTEND4_BETA, 0 },
|
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_5_IS_CUSTOM
|
2019-05-06 23:51:06 +00:00
|
|
|
{ true, 0, 0, HOTEND5_PULLUP_RESISTOR_OHMS, HOTEND5_RESISTANCE_25C_OHMS, 0, 0, HOTEND5_BETA, 0 },
|
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_6_IS_CUSTOM
|
2020-01-25 08:13:39 +00:00
|
|
|
{ true, 0, 0, HOTEND6_PULLUP_RESISTOR_OHMS, HOTEND6_RESISTANCE_25C_OHMS, 0, 0, HOTEND6_BETA, 0 },
|
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_7_IS_CUSTOM
|
2020-01-25 08:13:39 +00:00
|
|
|
{ true, 0, 0, HOTEND7_PULLUP_RESISTOR_OHMS, HOTEND7_RESISTANCE_25C_OHMS, 0, 0, HOTEND7_BETA, 0 },
|
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_BED_IS_CUSTOM
|
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
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_CHAMBER_IS_CUSTOM
|
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
|
2021-03-06 20:13:28 +00:00
|
|
|
#if TEMP_SENSOR_COOLER_IS_CUSTOM
|
|
|
|
{ true, 0, 0, COOLER_PULLUP_RESISTOR_OHMS, COOLER_RESISTANCE_25C_OHMS, 0, 0, COOLER_BETA, 0 }
|
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_PROBE_IS_CUSTOM
|
|
|
|
{ true, 0, 0, PROBE_PULLUP_RESISTOR_OHMS, PROBE_RESISTANCE_25C_OHMS, 0, 0, PROBE_BETA, 0 }
|
|
|
|
#endif
|
2019-05-06 23:51:06 +00:00
|
|
|
};
|
2021-01-04 03:39:15 +00:00
|
|
|
COPY(user_thermistor, default_user_thermistor);
|
2019-05-06 23:51:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Temperature::log_user_thermistor(const uint8_t t_index, const bool eprom/*=false*/) {
|
|
|
|
|
|
|
|
if (eprom)
|
|
|
|
SERIAL_ECHOPGM(" M305 ");
|
|
|
|
else
|
|
|
|
SERIAL_ECHO_START();
|
2021-01-05 12:18:09 +00:00
|
|
|
SERIAL_CHAR('P', '0' + t_index);
|
2019-05-06 23:51:06 +00:00
|
|
|
|
|
|
|
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(" ; ");
|
2021-03-01 01:43:46 +00:00
|
|
|
SERIAL_ECHOPGM_P(
|
2021-02-07 22:58:06 +00:00
|
|
|
TERN_(TEMP_SENSOR_0_IS_CUSTOM, t_index == CTI_HOTEND_0 ? PSTR("HOTEND 0") :)
|
|
|
|
TERN_(TEMP_SENSOR_1_IS_CUSTOM, t_index == CTI_HOTEND_1 ? PSTR("HOTEND 1") :)
|
|
|
|
TERN_(TEMP_SENSOR_2_IS_CUSTOM, t_index == CTI_HOTEND_2 ? PSTR("HOTEND 2") :)
|
|
|
|
TERN_(TEMP_SENSOR_3_IS_CUSTOM, t_index == CTI_HOTEND_3 ? PSTR("HOTEND 3") :)
|
|
|
|
TERN_(TEMP_SENSOR_4_IS_CUSTOM, t_index == CTI_HOTEND_4 ? PSTR("HOTEND 4") :)
|
|
|
|
TERN_(TEMP_SENSOR_5_IS_CUSTOM, t_index == CTI_HOTEND_5 ? PSTR("HOTEND 5") :)
|
|
|
|
TERN_(TEMP_SENSOR_6_IS_CUSTOM, t_index == CTI_HOTEND_6 ? PSTR("HOTEND 6") :)
|
|
|
|
TERN_(TEMP_SENSOR_7_IS_CUSTOM, t_index == CTI_HOTEND_7 ? PSTR("HOTEND 7") :)
|
|
|
|
TERN_(TEMP_SENSOR_BED_IS_CUSTOM, t_index == CTI_BED ? PSTR("BED") :)
|
|
|
|
TERN_(TEMP_SENSOR_CHAMBER_IS_CUSTOM, t_index == CTI_CHAMBER ? PSTR("CHAMBER") :)
|
2021-03-06 20:13:28 +00:00
|
|
|
TERN_(TEMP_SENSOR_COOLER_IS_CUSTOM, t_index == CTI_COOLER ? PSTR("COOLER") :)
|
2021-02-07 22:58:06 +00:00
|
|
|
TERN_(TEMP_SENSOR_PROBE_IS_CUSTOM, t_index == CTI_PROBE ? PSTR("PROBE") :)
|
2019-05-09 16:45:55 +00:00
|
|
|
nullptr
|
2019-05-06 23:51:06 +00:00
|
|
|
);
|
|
|
|
SERIAL_EOL();
|
|
|
|
}
|
|
|
|
|
2021-03-24 09:11:43 +00:00
|
|
|
celsius_t Temperature::user_thermistor_to_deg_c(const uint8_t t_index, const int raw) {
|
2019-05-06 23:51:06 +00:00
|
|
|
//#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.
|
2021-03-24 09:11:43 +00:00
|
|
|
celsius_t 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();
|
2021-02-08 06:37:24 +00:00
|
|
|
SERIAL_ECHO(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:
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_0_IS_CUSTOM
|
2019-09-10 07:20:49 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_0, raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_0_IS_MAX_TC
|
|
|
|
return TERN(TEMP_SENSOR_0_IS_MAX31865, max31865_0.temperature(MAX31865_SENSOR_OHMS_0, MAX31865_CALIBRATION_OHMS_0), raw * 0.25);
|
|
|
|
#elif TEMP_SENSOR_0_IS_AD595
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD595(raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_0_IS_AD8495
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 1:
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_1_IS_CUSTOM
|
2019-09-10 07:20:49 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_1, raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_1_IS_MAX_TC
|
|
|
|
return TERN(TEMP_SENSOR_1_IS_MAX31865, max31865_1.temperature(MAX31865_SENSOR_OHMS_1, MAX31865_CALIBRATION_OHMS_1), raw * 0.25);
|
|
|
|
#elif TEMP_SENSOR_1_IS_AD595
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD595(raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_1_IS_AD8495
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 2:
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_2_IS_CUSTOM
|
2019-09-10 07:20:49 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_2, raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_2_IS_AD595
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD595(raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_2_IS_AD8495
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 3:
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_3_IS_CUSTOM
|
2019-09-10 07:20:49 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_3, raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_3_IS_AD595
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD595(raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_3_IS_AD8495
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 4:
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_4_IS_CUSTOM
|
2019-09-10 07:20:49 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_4, raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_4_IS_AD595
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD595(raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_4_IS_AD8495
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 5:
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_5_IS_CUSTOM
|
2019-09-10 07:20:49 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_5, raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_5_IS_AD595
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD595(raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_5_IS_AD8495
|
2019-09-10 07:20:49 +00:00
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
2020-01-25 08:13:39 +00:00
|
|
|
case 6:
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_6_IS_CUSTOM
|
2020-01-25 08:13:39 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_6, raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_6_IS_AD595
|
2020-01-25 08:13:39 +00:00
|
|
|
return TEMP_AD595(raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_6_IS_AD8495
|
2020-01-25 08:13:39 +00:00
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 7:
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_7_IS_CUSTOM
|
2020-01-25 08:13:39 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_HOTEND_7, raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_7_IS_AD595
|
2020-01-25 08:13:39 +00:00
|
|
|
return TEMP_AD595(raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_7_IS_AD8495
|
2020-01-25 08:13:39 +00:00
|
|
|
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
|
|
|
|
2020-11-09 07:17:37 +00:00
|
|
|
#if HAS_HOTEND_THERMISTOR
|
2019-09-10 07:20:49 +00:00
|
|
|
// 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
|
|
|
// For bed temperature measurement.
|
2021-03-24 09:11:43 +00:00
|
|
|
celsius_t Temperature::analog_to_celsius_bed(const int raw) {
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_BED_IS_CUSTOM
|
2019-05-06 23:51:06 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_BED, raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_BED_IS_THERMISTOR
|
|
|
|
SCAN_THERMISTOR_TABLE(TEMPTABLE_BED, TEMPTABLE_BED_LEN);
|
|
|
|
#elif TEMP_SENSOR_BED_IS_AD595
|
2018-05-11 06:01:51 +00:00
|
|
|
return TEMP_AD595(raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_BED_IS_AD8495
|
2018-05-11 06:01:51 +00:00
|
|
|
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
|
|
|
|
// For chamber temperature measurement.
|
2021-03-24 09:11:43 +00:00
|
|
|
celsius_t Temperature::analog_to_celsius_chamber(const int raw) {
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_CHAMBER_IS_CUSTOM
|
2019-05-06 23:51:06 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_CHAMBER, raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_CHAMBER_IS_THERMISTOR
|
|
|
|
SCAN_THERMISTOR_TABLE(TEMPTABLE_CHAMBER, TEMPTABLE_CHAMBER_LEN);
|
|
|
|
#elif TEMP_SENSOR_CHAMBER_IS_AD595
|
2018-05-11 06:01:51 +00:00
|
|
|
return TEMP_AD595(raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_CHAMBER_IS_AD8495
|
2018-05-11 06:01:51 +00:00
|
|
|
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
|
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_TEMP_COOLER
|
|
|
|
// For cooler temperature measurement.
|
2021-03-24 09:11:43 +00:00
|
|
|
celsius_t Temperature::analog_to_celsius_cooler(const int raw) {
|
2021-03-06 20:13:28 +00:00
|
|
|
#if TEMP_SENSOR_COOLER_IS_CUSTOM
|
|
|
|
return user_thermistor_to_deg_c(CTI_COOLER, raw);
|
|
|
|
#elif TEMP_SENSOR_COOLER_IS_THERMISTOR
|
|
|
|
SCAN_THERMISTOR_TABLE(TEMPTABLE_COOLER, TEMPTABLE_COOLER_LEN);
|
|
|
|
#elif TEMP_SENSOR_COOLER_IS_AD595
|
|
|
|
return TEMP_AD595(raw);
|
|
|
|
#elif TEMP_SENSOR_COOLER_IS_AD8495
|
|
|
|
return TEMP_AD8495(raw);
|
|
|
|
#else
|
|
|
|
UNUSED(raw);
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif // HAS_TEMP_COOLER
|
|
|
|
|
2020-01-17 23:16:45 +00:00
|
|
|
#if HAS_TEMP_PROBE
|
|
|
|
// For probe temperature measurement.
|
2021-03-24 09:11:43 +00:00
|
|
|
celsius_t Temperature::analog_to_celsius_probe(const int raw) {
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_PROBE_IS_CUSTOM
|
2020-01-17 23:16:45 +00:00
|
|
|
return user_thermistor_to_deg_c(CTI_PROBE, raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_PROBE_IS_THERMISTOR
|
|
|
|
SCAN_THERMISTOR_TABLE(TEMPTABLE_PROBE, TEMPTABLE_PROBE_LEN);
|
|
|
|
#elif TEMP_SENSOR_PROBE_IS_AD595
|
2020-01-17 23:16:45 +00:00
|
|
|
return TEMP_AD595(raw);
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif TEMP_SENSOR_PROBE_IS_AD8495
|
2020-01-17 23:16:45 +00:00
|
|
|
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() {
|
2021-02-07 22:58:06 +00:00
|
|
|
TERN_(TEMP_SENSOR_0_IS_MAX_TC, temp_hotend[0].raw = READ_MAX_TC(0));
|
|
|
|
TERN_(TEMP_SENSOR_1_IS_MAX_TC, temp_hotend[1].raw = READ_MAX_TC(1));
|
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-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));
|
2021-03-06 20:13:28 +00:00
|
|
|
TERN_(HAS_TEMP_COOLER, temp_cooler.celsius = analog_to_celsius_cooler(temp_cooler.raw));
|
2020-04-22 21:35:03 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
#if THERMO_SEPARATE_SPI
|
2020-09-22 20:44:17 +00:00
|
|
|
template<uint8_t MisoPin, uint8_t MosiPin, uint8_t SckPin> SoftSPI<MisoPin, MosiPin, SckPin> SPIclass<MisoPin, MosiPin, SckPin>::softSPI;
|
2021-02-07 22:58:06 +00:00
|
|
|
SPIclass<MAX6675_DO_PIN, SD_MOSI_PIN, MAX6675_SCK_PIN> max_tc_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
|
2021-02-25 10:35:18 +00:00
|
|
|
#ifdef BOARD_OPENDRAIN_MOSFETS
|
2019-07-14 23:05:24 +00:00
|
|
|
#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
|
2020-11-21 01:53:04 +00:00
|
|
|
#define INIT_E_AUTO_FAN_PIN(P) do{ if (P == FAN1_PIN || P == FAN2_PIN) { SET_PWM(P); SET_FAST_PWM_FREQ(P); } else SET_OUTPUT(P); }while(0)
|
2019-05-05 03:51:47 +00:00
|
|
|
#else
|
|
|
|
#define INIT_E_AUTO_FAN_PIN(P) SET_OUTPUT(P)
|
|
|
|
#endif
|
|
|
|
#if CHAMBER_AUTO_FAN_SPEED != 255
|
2020-11-21 01:53:04 +00:00
|
|
|
#define INIT_CHAMBER_AUTO_FAN_PIN(P) do{ if (P == FAN1_PIN || P == FAN2_PIN) { SET_PWM(P); SET_FAST_PWM_FREQ(P); } 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() {
|
2021-02-09 01:51:57 +00:00
|
|
|
// Init (and disable) SPI thermocouples
|
|
|
|
#if TEMP_SENSOR_0_IS_MAX6675 && PIN_EXISTS(MAX6675_CS)
|
|
|
|
OUT_WRITE(MAX6675_CS_PIN, HIGH);
|
|
|
|
#endif
|
|
|
|
#if TEMP_SENSOR_1_IS_MAX6675 && PIN_EXISTS(MAX6675_CS2)
|
|
|
|
OUT_WRITE(MAX6675_CS2_PIN, HIGH);
|
|
|
|
#endif
|
|
|
|
#if TEMP_SENSOR_0_IS_MAX6675 && PIN_EXISTS(MAX31855_CS)
|
|
|
|
OUT_WRITE(MAX31855_CS_PIN, HIGH);
|
|
|
|
#endif
|
|
|
|
#if TEMP_SENSOR_1_IS_MAX6675 && PIN_EXISTS(MAX31855_CS2)
|
|
|
|
OUT_WRITE(MAX31855_CS2_PIN, HIGH);
|
|
|
|
#endif
|
|
|
|
#if TEMP_SENSOR_0_IS_MAX6675 && PIN_EXISTS(MAX31865_CS)
|
|
|
|
OUT_WRITE(MAX31865_CS_PIN, HIGH);
|
|
|
|
#endif
|
|
|
|
#if TEMP_SENSOR_1_IS_MAX6675 && PIN_EXISTS(MAX31865_CS2)
|
|
|
|
OUT_WRITE(MAX31865_CS2_PIN, HIGH);
|
|
|
|
#endif
|
2016-04-29 01:18:13 +00:00
|
|
|
|
2021-02-09 01:51:57 +00:00
|
|
|
#if HAS_MAX31865_TEMP
|
|
|
|
TERN_(TEMP_SENSOR_0_IS_MAX31865, max31865_0.begin(MAX31865_2WIRE)); // MAX31865_2WIRE, MAX31865_3WIRE, MAX31865_4WIRE
|
|
|
|
TERN_(TEMP_SENSOR_1_IS_MAX31865, max31865_1.begin(MAX31865_2WIRE));
|
|
|
|
#endif
|
|
|
|
#if HAS_MAX31855_TEMP
|
|
|
|
TERN_(TEMP_SENSOR_0_IS_MAX31855, max31855_0.begin());
|
|
|
|
TERN_(TEMP_SENSOR_1_IS_MAX31855, max31855_1.begin());
|
|
|
|
#endif
|
|
|
|
#if HAS_MAX6675_TEMP
|
|
|
|
TERN_(TEMP_SENSOR_0_IS_MAX6675, max6675_0.begin());
|
|
|
|
TERN_(TEMP_SENSOR_1_IS_MAX6675, max6675_1.begin());
|
|
|
|
#endif
|
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
|
2021-02-07 22:58:06 +00:00
|
|
|
#define _AD(N) (TEMP_SENSOR_##N##_IS_AD595 || TEMP_SENSOR_##N##_IS_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
|
2021-02-07 22:58:06 +00:00
|
|
|
#if PIN_EXISTS(TEMP_0_TR_ENABLE)
|
|
|
|
OUT_WRITE(TEMP_0_TR_ENABLE_PIN, ENABLED(TEMP_SENSOR_0_IS_MAX_TC));
|
2020-07-06 22:08:52 +00:00
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if PIN_EXISTS(TEMP_1_TR_ENABLE)
|
|
|
|
OUT_WRITE(TEMP_1_TR_ENABLE_PIN, ENABLED(TEMP_SENSOR_1_IS_MAX_TC));
|
2020-07-06 22:08:52 +00:00
|
|
|
#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
|
2021-02-25 10:35:18 +00:00
|
|
|
#ifdef BOARD_OPENDRAIN_MOSFETS
|
2019-07-14 23:05:24 +00:00
|
|
|
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
|
2021-02-25 10:35:18 +00:00
|
|
|
#ifdef BOARD_OPENDRAIN_MOSFETS
|
2019-07-14 23:05:24 +00:00
|
|
|
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
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
OUT_WRITE(COOLER_PIN, COOLER_INVERTING);
|
|
|
|
#endif
|
|
|
|
|
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
|
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
TERN_(THERMO_SEPARATE_SPI, max_tc_spi.init());
|
2018-11-17 00:20:33 +00:00
|
|
|
|
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
|
2020-11-23 00:47:52 +00:00
|
|
|
#if HAS_TEMP_ADC_BED
|
2017-06-17 23:36:10 +00:00
|
|
|
HAL_ANALOG_SELECT(TEMP_BED_PIN);
|
2011-12-06 04:33:33 +00:00
|
|
|
#endif
|
2020-11-23 00:47:52 +00:00
|
|
|
#if HAS_TEMP_ADC_CHAMBER
|
2018-02-24 06:38:58 +00:00
|
|
|
HAL_ANALOG_SELECT(TEMP_CHAMBER_PIN);
|
|
|
|
#endif
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_TEMP_ADC_COOLER
|
|
|
|
HAL_ANALOG_SELECT(TEMP_COOLER_PIN);
|
|
|
|
#endif
|
2020-11-23 00:47:52 +00:00
|
|
|
#if HAS_TEMP_ADC_PROBE
|
2020-01-17 23:16:45 +00:00
|
|
|
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{ \
|
2021-03-24 09:11:43 +00:00
|
|
|
const celsius_t tmin = _MAX(HEATER_##NR##_MINTEMP, TERN(TEMP_SENSOR_##NR##_IS_CUSTOM, 0, pgm_read_word(&TEMPTABLE_##NR [TEMP_SENSOR_##NR##_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{ \
|
2021-03-24 09:11:43 +00:00
|
|
|
const celsius_t tmax = _MIN(HEATER_##NR##_MAXTEMP, TERN(TEMP_SENSOR_##NR##_IS_CUSTOM, 2000, pgm_read_word(&TEMPTABLE_##NR [TEMP_SENSOR_##NR##_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)
|
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
#define _MINMAX_TEST(N,M) (HOTENDS > N && TEMP_SENSOR_ ##N## THERMISTOR_ID && TEMP_SENSOR_ ##N## THERMISTOR_ID != 998 && TEMP_SENSOR_ ##N## THERMISTOR_ID != 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
|
2021-03-24 09:11:43 +00:00
|
|
|
while (analog_to_celsius_bed(mintemp_raw_BED) < BED_MINTEMP) mintemp_raw_BED += TEMPDIR(BED) * (OVERSAMPLENR);
|
|
|
|
while (analog_to_celsius_bed(maxtemp_raw_BED) > BED_MAXTEMP) maxtemp_raw_BED -= TEMPDIR(BED) * (OVERSAMPLENR);
|
|
|
|
#endif
|
2017-05-07 11:06:06 +00:00
|
|
|
|
2019-03-07 08:09:39 +00:00
|
|
|
#if HAS_HEATED_CHAMBER
|
2021-03-24 09:11:43 +00:00
|
|
|
while (analog_to_celsius_chamber(mintemp_raw_CHAMBER) < CHAMBER_MINTEMP) mintemp_raw_CHAMBER += TEMPDIR(CHAMBER) * (OVERSAMPLENR);
|
|
|
|
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
|
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
2021-03-24 09:11:43 +00:00
|
|
|
while (analog_to_celsius_cooler(mintemp_raw_COOLER) > COOLER_MINTEMP) mintemp_raw_COOLER += TEMPDIR(COOLER) * (OVERSAMPLENR);
|
|
|
|
while (analog_to_celsius_cooler(maxtemp_raw_COOLER) < COOLER_MAXTEMP) maxtemp_raw_COOLER -= TEMPDIR(COOLER) * (OVERSAMPLENR);
|
2021-03-06 20:13:28 +00:00
|
|
|
#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
|
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if WATCH_COOLER
|
|
|
|
/**
|
|
|
|
* Start Cooling Sanity Check for cooler that is above
|
|
|
|
* its target temperature by a configurable margin.
|
|
|
|
* This is called when the temperature is set. (M143, M193)
|
|
|
|
*/
|
|
|
|
void Temperature::start_watching_cooler() {
|
|
|
|
watch_cooler.restart(degCooler(), degTargetCooler());
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-04-22 01:50:32 +00:00
|
|
|
#if HAS_THERMAL_PROTECTION
|
2015-04-02 12:10:14 +00:00
|
|
|
|
2020-09-14 04:58:39 +00:00
|
|
|
Temperature::tr_state_machine_t Temperature::tr_state_machine[NR_HEATER_RUNAWAY]; // = { { TRInactive, 0 } };
|
2016-05-26 18:58:38 +00:00
|
|
|
|
2020-09-14 04:58:39 +00:00
|
|
|
/**
|
|
|
|
* @brief Thermal Runaway state machine for a single heater
|
|
|
|
* @param current current measured temperature
|
|
|
|
* @param target current target temperature
|
|
|
|
* @param heater_id extruder index
|
|
|
|
* @param period_seconds missed temperature allowed time
|
|
|
|
* @param hysteresis_degc allowed distance from target
|
|
|
|
*
|
|
|
|
* TODO: Embed the last 3 parameters during init, if not less optimal
|
|
|
|
*/
|
2021-03-24 09:11:43 +00:00
|
|
|
void Temperature::tr_state_machine_t::run(const float ¤t, const float &target, const heater_id_t heater_id, const uint16_t period_seconds, const celsius_t hysteresis_degc) {
|
2015-04-04 02:34:55 +00:00
|
|
|
|
2020-09-14 04:58:39 +00:00
|
|
|
#if HEATER_IDLE_HANDLER
|
|
|
|
// Convert the given heater_id_t to an idle array index
|
|
|
|
const IdleIndex idle_index = idle_index_for_id(heater_id);
|
|
|
|
#endif
|
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: ");
|
2020-09-14 04:58:39 +00:00
|
|
|
switch (heater_id) {
|
|
|
|
case H_BED: SERIAL_ECHOPGM("bed"); break;
|
|
|
|
case H_CHAMBER: SERIAL_ECHOPGM("chamber"); break;
|
2021-02-08 06:37:24 +00:00
|
|
|
default: SERIAL_ECHO(heater_id);
|
2020-09-14 04:58:39 +00:00
|
|
|
}
|
|
|
|
SERIAL_ECHOLNPAIR(
|
|
|
|
" ; sizeof(running_temp):", sizeof(running_temp),
|
|
|
|
" ; State:", state, " ; Timer:", timer, " ; Temperature:", current, " ; Target Temp:", target
|
|
|
|
#if HEATER_IDLE_HANDLER
|
|
|
|
, " ; Idle Timeout:", heater_idle[idle_index].timed_out
|
|
|
|
#endif
|
|
|
|
);
|
2019-04-22 01:50:32 +00:00
|
|
|
//*/
|
2015-04-04 12:45:36 +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
|
2020-09-14 04:58:39 +00:00
|
|
|
if (heater_idle[idle_index].timed_out) {
|
|
|
|
state = TRInactive;
|
|
|
|
running_temp = 0;
|
2017-05-26 18:01:02 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
2018-01-02 00:24:54 +00:00
|
|
|
{
|
|
|
|
// If the target temperature changes, restart
|
2020-09-14 04:58:39 +00:00
|
|
|
if (running_temp != target) {
|
|
|
|
running_temp = target;
|
|
|
|
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
|
|
|
|
2020-09-14 04:58:39 +00:00
|
|
|
switch (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:
|
2020-09-14 04:58:39 +00:00
|
|
|
if (current < running_temp) break;
|
|
|
|
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);
|
2020-09-14 04:58:39 +00:00
|
|
|
if (fan_speed[fan_index] == 0 || current >= running_temp - (hysteresis_degc * 0.25f))
|
2019-01-12 06:41:48 +00:00
|
|
|
fan_speed_scaler[fan_index] = 128;
|
2020-09-14 04:58:39 +00:00
|
|
|
else if (current >= running_temp - (hysteresis_degc * 0.3335f))
|
2019-01-12 06:41:48 +00:00
|
|
|
fan_speed_scaler[fan_index] = 96;
|
2020-09-14 04:58:39 +00:00
|
|
|
else if (current >= running_temp - (hysteresis_degc * 0.5f))
|
2019-01-12 06:41:48 +00:00
|
|
|
fan_speed_scaler[fan_index] = 64;
|
2020-09-14 04:58:39 +00:00
|
|
|
else if (current >= running_temp - (hysteresis_degc * 0.8f))
|
2019-01-12 06:41:48 +00:00
|
|
|
fan_speed_scaler[fan_index] = 32;
|
|
|
|
else
|
|
|
|
fan_speed_scaler[fan_index] = 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-09-14 04:58:39 +00:00
|
|
|
if (current >= running_temp - hysteresis_degc) {
|
|
|
|
timer = millis() + SEC_TO_MS(period_seconds);
|
2016-05-08 23:51:33 +00:00
|
|
|
break;
|
|
|
|
}
|
2020-09-14 04:58:39 +00:00
|
|
|
else if (PENDING(millis(), timer)) break;
|
|
|
|
state = TRRunaway;
|
2019-01-12 06:41:48 +00:00
|
|
|
|
2015-04-04 12:45:36 +00:00
|
|
|
case TRRunaway:
|
2020-09-17 10:35:04 +00:00
|
|
|
TERN_(DWIN_CREALITY_LCD, DWIN_Popup_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
|
2021-03-06 20:13:28 +00:00
|
|
|
|
|
|
|
#if HAS_COOLER
|
|
|
|
setTargetCooler(0);
|
|
|
|
temp_cooler.soft_pwm_amount = 0;
|
|
|
|
WRITE_HEATER_COOLER(LOW);
|
|
|
|
#endif
|
2011-11-15 21:50:43 +00:00
|
|
|
}
|
|
|
|
|
2020-01-30 09:24:43 +00:00
|
|
|
#if ENABLED(PRINTJOB_TIMER_AUTOSTART)
|
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#include "printcounter.h"
|
|
|
|
|
2020-11-07 23:55:31 +00:00
|
|
|
bool Temperature::auto_job_over_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
|
|
|
}
|
|
|
|
|
2020-11-07 23:55:31 +00:00
|
|
|
void Temperature::auto_job_check_timer(const bool can_start, const bool can_stop) {
|
|
|
|
if (auto_job_over_threshold()) {
|
2020-01-30 09:24:43 +00:00
|
|
|
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-09-14 04:58:39 +00:00
|
|
|
HOTEND_LOOP() heater_idle[e].expire(); // Timeout immediately
|
|
|
|
TERN_(HAS_HEATED_BED, heater_idle[IDLE_INDEX_BED].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
|
|
|
|
2021-01-20 02:58:50 +00:00
|
|
|
#if ENABLED(SINGLENOZZLE_STANDBY_TEMP)
|
|
|
|
|
|
|
|
void Temperature::singlenozzle_change(const uint8_t old_tool, const uint8_t new_tool) {
|
|
|
|
#if HAS_FAN
|
|
|
|
singlenozzle_fan_speed[old_tool] = fan_speed[0];
|
|
|
|
fan_speed[0] = singlenozzle_fan_speed[new_tool];
|
|
|
|
#endif
|
|
|
|
singlenozzle_temp[old_tool] = temp_hotend[0].target;
|
|
|
|
if (singlenozzle_temp[new_tool] && singlenozzle_temp[new_tool] != singlenozzle_temp[old_tool]) {
|
|
|
|
setTargetHotend(singlenozzle_temp[new_tool], 0);
|
|
|
|
TERN_(AUTOTEMP, planner.autotemp_update());
|
2021-03-24 15:12:57 +00:00
|
|
|
TERN_(HAS_STATUS_MESSAGE, set_heating_message(0));
|
2021-01-20 02:58:50 +00:00
|
|
|
(void)wait_for_hotend(0, false); // Wait for heating or cooling
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
#if HAS_MAX_TC
|
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
|
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
int Temperature::read_max_tc(TERN_(HAS_MULTI_MAX_TC, const uint8_t hindex/*=0*/)) {
|
2018-11-17 00:20:33 +00:00
|
|
|
#define MAX6675_HEAT_INTERVAL 250UL
|
2012-02-05 12:05:07 +00:00
|
|
|
|
2021-02-09 01:51:57 +00:00
|
|
|
#if HAS_MAX31855_TEMP
|
2021-02-07 22:58:06 +00:00
|
|
|
static uint32_t max_tc_temp = 2000;
|
|
|
|
#define MAX_TC_ERROR_MASK 7
|
|
|
|
#define MAX_TC_DISCARD_BITS 18
|
|
|
|
#define MAX_TC_SPEED_BITS 3 // (_BV(SPR1)) // clock ÷ 64
|
|
|
|
#elif HAS_MAX31865_TEMP
|
|
|
|
static uint16_t max_tc_temp = 2000; // From datasheet 16 bits D15-D0
|
|
|
|
#define MAX_TC_ERROR_MASK 1 // D0 Bit not used
|
|
|
|
#define MAX_TC_DISCARD_BITS 1 // Data is in D15-D1
|
|
|
|
#define MAX_TC_SPEED_BITS 3 // (_BV(SPR1)) // clock ÷ 64
|
2018-11-17 00:20:33 +00:00
|
|
|
#else
|
2021-02-07 22:58:06 +00:00
|
|
|
static uint16_t max_tc_temp = 2000;
|
|
|
|
#define MAX_TC_ERROR_MASK 4
|
|
|
|
#define MAX_TC_DISCARD_BITS 3
|
|
|
|
#define MAX_TC_SPEED_BITS 2 // (_BV(SPR0)) // clock ÷ 16
|
2018-11-17 00:20:33 +00:00
|
|
|
#endif
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
#if HAS_MULTI_MAX_TC
|
2020-11-11 21:52:35 +00:00
|
|
|
// Needed to return the correct temp when this is called between readings
|
2021-03-24 09:11:43 +00:00
|
|
|
static celsius_t max_tc_temp_previous[MAX_TC_COUNT] = { 0 };
|
2021-02-07 22:58:06 +00:00
|
|
|
#define THERMO_TEMP(I) max_tc_temp_previous[I]
|
|
|
|
#define THERMO_SEL(A,B) (hindex ? (B) : (A))
|
2020-11-11 21:52:35 +00:00
|
|
|
#define MAX6675_WRITE(V) do{ switch (hindex) { case 1: WRITE(MAX6675_SS2_PIN, V); break; default: WRITE(MAX6675_SS_PIN, V); } }while(0)
|
|
|
|
#define MAX6675_SET_OUTPUT() do{ switch (hindex) { case 1: SET_OUTPUT(MAX6675_SS2_PIN); break; default: SET_OUTPUT(MAX6675_SS_PIN); } }while(0)
|
|
|
|
#else
|
|
|
|
constexpr uint8_t hindex = 0;
|
2021-02-07 22:58:06 +00:00
|
|
|
#define THERMO_TEMP(I) max_tc_temp
|
|
|
|
#if TEMP_SENSOR_1_IS_MAX31865
|
|
|
|
#define THERMO_SEL(A,B) B
|
2020-11-11 21:52:35 +00:00
|
|
|
#else
|
2021-02-07 22:58:06 +00:00
|
|
|
#define THERMO_SEL(A,B) A
|
2020-11-11 21:52:35 +00:00
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
#if TEMP_SENSOR_0_IS_MAX6675
|
2020-11-11 21:52:35 +00:00
|
|
|
#define MAX6675_WRITE(V) WRITE(MAX6675_SS_PIN, V)
|
|
|
|
#define MAX6675_SET_OUTPUT() SET_OUTPUT(MAX6675_SS_PIN)
|
|
|
|
#else
|
|
|
|
#define MAX6675_WRITE(V) WRITE(MAX6675_SS2_PIN, V)
|
|
|
|
#define MAX6675_SET_OUTPUT() SET_OUTPUT(MAX6675_SS2_PIN)
|
|
|
|
#endif
|
2021-02-07 22:58:06 +00:00
|
|
|
|
2020-11-11 21:52:35 +00:00
|
|
|
#endif
|
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
static uint8_t max_tc_errors[MAX_TC_COUNT] = { 0 };
|
2020-11-11 21:52:35 +00:00
|
|
|
|
2018-11-17 00:20:33 +00:00
|
|
|
// Return last-read value between readings
|
2021-02-07 22:58:06 +00:00
|
|
|
static millis_t next_max_tc_ms[MAX_TC_COUNT] = { 0 };
|
2015-04-13 01:07:08 +00:00
|
|
|
millis_t ms = millis();
|
2021-02-07 22:58:06 +00:00
|
|
|
if (PENDING(ms, next_max_tc_ms[hindex])) return int(THERMO_TEMP(hindex));
|
|
|
|
next_max_tc_ms[hindex] = ms + MAX6675_HEAT_INTERVAL;
|
2018-11-17 00:20:33 +00:00
|
|
|
|
|
|
|
//
|
|
|
|
// TODO: spiBegin, spiRec and spiInit doesn't work when soft spi is used.
|
|
|
|
//
|
2021-02-09 01:51:57 +00:00
|
|
|
#if !THERMO_SEPARATE_SPI && NO_THERMO_TEMPS
|
2018-11-17 00:20:33 +00:00
|
|
|
spiBegin();
|
2021-02-07 22:58:06 +00:00
|
|
|
spiInit(MAX_TC_SPEED_BITS);
|
2018-11-17 00:20:33 +00:00
|
|
|
#endif
|
2015-04-13 06:06:50 +00:00
|
|
|
|
2021-02-09 01:51:57 +00:00
|
|
|
#if NO_THERMO_TEMPS
|
|
|
|
MAX6675_WRITE(LOW); // enable TT_MAX6675
|
|
|
|
DELAY_NS(100); // Ensure 100ns delay
|
|
|
|
#endif
|
2012-02-05 12:05:07 +00:00
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
max_tc_temp = 0;
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2021-02-09 01:51:57 +00:00
|
|
|
// Read a big-endian temperature value
|
|
|
|
#if NO_THERMO_TEMPS
|
|
|
|
for (uint8_t i = sizeof(max_tc_temp); i--;) {
|
|
|
|
max_tc_temp |= TERN(THERMO_SEPARATE_SPI, max_tc_spi.receive(), spiRec());
|
|
|
|
if (i > 0) max_tc_temp <<= 8; // shift left if not the last byte
|
|
|
|
}
|
|
|
|
MAX6675_WRITE(HIGH); // disable TT_MAX6675
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_MAX31855_TEMP
|
|
|
|
Adafruit_MAX31855 &max855ref = THERMO_SEL(max31855_0, max31855_1);
|
|
|
|
max_tc_temp = max855ref.readRaw32();
|
|
|
|
#endif
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2021-02-09 01:51:57 +00:00
|
|
|
#if HAS_MAX31865_TEMP
|
|
|
|
Adafruit_MAX31865 &max865ref = THERMO_SEL(max31865_0, max31865_1);
|
|
|
|
#if ENABLED(LIB_USR_MAX31865)
|
|
|
|
max_tc_temp = max865ref.readRTD_with_Fault();
|
|
|
|
#endif
|
|
|
|
#endif
|
2020-11-11 21:52:35 +00:00
|
|
|
|
2021-02-09 01:51:57 +00:00
|
|
|
#if HAS_MAX6675_TEMP
|
|
|
|
MAX6675 &max6675ref = THERMO_SEL(max6675_0, max6675_1);
|
|
|
|
max_tc_temp = max6675ref.readRaw16();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(LIB_ADAFRUIT_MAX31865)
|
|
|
|
const uint8_t fault_31865 = max865ref.readFault() & 0x3FU;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (DISABLED(IGNORE_THERMOCOUPLE_ERRORS)
|
|
|
|
&& TERN(LIB_ADAFRUIT_MAX31865, fault_31865, (max_tc_temp & MAX_TC_ERROR_MASK))
|
|
|
|
) {
|
2021-02-07 22:58:06 +00:00
|
|
|
max_tc_errors[hindex]++;
|
|
|
|
if (max_tc_errors[hindex] > THERMOCOUPLE_MAX_ERRORS) {
|
2020-05-20 20:38:29 +00:00
|
|
|
SERIAL_ERROR_START();
|
|
|
|
SERIAL_ECHOPGM("Temp measurement error! ");
|
2021-02-07 22:58:06 +00:00
|
|
|
#if MAX_TC_ERROR_MASK == 7
|
2021-02-09 01:51:57 +00:00
|
|
|
SERIAL_ECHOPGM("MAX31855 Fault : (", max_tc_temp & 0x7, ") >> ");
|
|
|
|
if (max_tc_temp & 0x1)
|
2020-05-20 20:38:29 +00:00
|
|
|
SERIAL_ECHOLNPGM("Open Circuit");
|
2021-02-09 01:51:57 +00:00
|
|
|
else if (max_tc_temp & 0x2)
|
2020-05-20 20:38:29 +00:00
|
|
|
SERIAL_ECHOLNPGM("Short to GND");
|
2021-02-09 01:51:57 +00:00
|
|
|
else if (max_tc_temp & 0x4)
|
2020-05-20 20:38:29 +00:00
|
|
|
SERIAL_ECHOLNPGM("Short to VCC");
|
2021-02-09 01:51:57 +00:00
|
|
|
#elif HAS_MAX31865
|
|
|
|
#if ENABLED(LIB_USR_MAX31865)
|
|
|
|
// At the present time we do not have the ability to set the MAX31865 HIGH threshold
|
|
|
|
// or thr LOW threshold, so no need to check for them, zero these bits out
|
|
|
|
const uint8_t fault_31865 = max865ref.readFault() & 0x3FU;
|
|
|
|
#endif
|
|
|
|
max865ref.clearFault();
|
2020-11-11 21:52:35 +00:00
|
|
|
if (fault_31865) {
|
2021-02-09 01:51:57 +00:00
|
|
|
SERIAL_EOL();
|
|
|
|
SERIAL_ECHOLNPAIR("\nMAX31865 Fault :(", fault_31865, ") >>");
|
2020-11-11 21:52:35 +00:00
|
|
|
if (fault_31865 & MAX31865_FAULT_HIGHTHRESH)
|
|
|
|
SERIAL_ECHOLNPGM("RTD High Threshold");
|
2021-02-09 01:51:57 +00:00
|
|
|
if (fault_31865 & MAX31865_FAULT_LOWTHRESH)
|
2020-11-11 21:52:35 +00:00
|
|
|
SERIAL_ECHOLNPGM("RTD Low Threshold");
|
2021-02-09 01:51:57 +00:00
|
|
|
if (fault_31865 & MAX31865_FAULT_REFINLOW)
|
2020-11-11 21:52:35 +00:00
|
|
|
SERIAL_ECHOLNPGM("REFIN- > 0.85 x Bias");
|
2021-02-09 01:51:57 +00:00
|
|
|
if (fault_31865 & MAX31865_FAULT_REFINHIGH)
|
2020-11-11 21:52:35 +00:00
|
|
|
SERIAL_ECHOLNPGM("REFIN- < 0.85 x Bias - FORCE- open");
|
2021-02-09 01:51:57 +00:00
|
|
|
if (fault_31865 & MAX31865_FAULT_RTDINLOW)
|
2020-11-11 21:52:35 +00:00
|
|
|
SERIAL_ECHOLNPGM("REFIN- < 0.85 x Bias - FORCE- open");
|
2021-02-09 01:51:57 +00:00
|
|
|
if (fault_31865 & MAX31865_FAULT_OVUV)
|
2020-11-11 21:52:35 +00:00
|
|
|
SERIAL_ECHOLNPGM("Under/Over voltage");
|
|
|
|
}
|
2018-11-17 00:20:33 +00:00
|
|
|
#else
|
2021-02-09 01:51:57 +00:00
|
|
|
SERIAL_ECHOLNPGM("MAX6675 Open Circuit");
|
2018-11-17 00:20:33 +00:00
|
|
|
#endif
|
2020-05-20 20:38:29 +00:00
|
|
|
|
|
|
|
// Thermocouple open
|
2021-02-07 22:58:06 +00:00
|
|
|
max_tc_temp = 4 * THERMO_SEL(TEMP_SENSOR_0_MAX_TC_TMAX, TEMP_SENSOR_1_MAX_TC_TMAX);
|
2020-05-20 20:38:29 +00:00
|
|
|
}
|
2020-07-11 05:23:48 +00:00
|
|
|
else
|
2021-02-07 22:58:06 +00:00
|
|
|
max_tc_temp >>= MAX_TC_DISCARD_BITS;
|
2016-10-09 22:12:50 +00:00
|
|
|
}
|
2020-05-20 20:38:29 +00:00
|
|
|
else {
|
2021-02-07 22:58:06 +00:00
|
|
|
max_tc_temp >>= MAX_TC_DISCARD_BITS;
|
|
|
|
max_tc_errors[hindex] = 0;
|
2020-05-20 20:38:29 +00:00
|
|
|
}
|
2019-01-14 20:29:55 +00:00
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
#if HAS_MAX31855
|
|
|
|
if (max_tc_temp & 0x00002000) max_tc_temp |= 0xFFFFC000; // Support negative temperature
|
2019-01-14 20:29:55 +00:00
|
|
|
#endif
|
|
|
|
|
2020-11-19 05:12:03 +00:00
|
|
|
// Return the RTD resistance for MAX31865 for display in SHOW_TEMP_ADC_VALUES
|
2021-02-09 01:51:57 +00:00
|
|
|
#if HAS_MAX31865_TEMP
|
|
|
|
#if ENABLED(LIB_ADAFRUIT_MAX31865)
|
|
|
|
max_tc_temp = (uint32_t(max865ref.readRTD()) * THERMO_SEL(MAX31865_CALIBRATION_OHMS_0, MAX31865_CALIBRATION_OHMS_1)) >> 16;
|
|
|
|
#elif ENABLED(LIB_USR_MAX31865)
|
|
|
|
max_tc_temp = (uint32_t(max_tc_temp) * THERMO_SEL(MAX31865_CALIBRATION_OHMS_0, MAX31865_CALIBRATION_OHMS_1)) >> 16;
|
|
|
|
#endif
|
|
|
|
#endif
|
2020-11-19 05:12:03 +00:00
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
THERMO_TEMP(hindex) = max_tc_temp;
|
2015-02-24 12:46:11 +00:00
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
return int(max_tc_temp);
|
2015-02-24 12:46:11 +00:00
|
|
|
}
|
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
#endif // HAS_MAX_TC
|
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
|
|
|
|
2021-02-07 22:58:06 +00:00
|
|
|
#if HAS_TEMP_ADC_0 && !TEMP_SENSOR_0_IS_MAX_TC
|
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;
|
2021-02-07 22:58:06 +00:00
|
|
|
#elif !TEMP_SENSOR_1_IS_MAX_TC
|
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());
|
2020-11-23 00:47:52 +00:00
|
|
|
TERN_(HAS_TEMP_ADC_BED, temp_bed.update());
|
|
|
|
TERN_(HAS_TEMP_ADC_CHAMBER, temp_chamber.update());
|
|
|
|
TERN_(HAS_TEMP_ADC_PROBE, temp_probe.update());
|
2021-03-06 20:13:28 +00:00
|
|
|
TERN_(HAS_TEMP_ADC_COOLER, temp_cooler.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());
|
2021-03-06 20:13:28 +00:00
|
|
|
TERN_(HAS_TEMP_COOLER, temp_cooler.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[] = {
|
2021-02-07 22:58:06 +00:00
|
|
|
TERN(TEMP_SENSOR_0_IS_MAX_TC, 0, TEMPDIR(0))
|
2020-04-20 04:56:55 +00:00
|
|
|
#if HAS_MULTI_HOTEND
|
2021-02-07 22:58:06 +00:00
|
|
|
, TERN(TEMP_SENSOR_1_IS_MAX_TC, 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
|
|
|
|
2021-01-04 03:39:15 +00:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_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-09-14 04:58:39 +00:00
|
|
|
const bool bed_on = (temp_bed.target > 0) || TERN0(PIDTEMPBED, temp_bed.soft_pwm_amount > 0);
|
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
|
|
|
|
|
2021-01-04 03:39:15 +00:00
|
|
|
#if BOTH(HAS_HEATED_CHAMBER, THERMAL_PROTECTION_CHAMBER)
|
2019-03-10 14:51:13 +00:00
|
|
|
#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
|
2021-03-06 20:13:28 +00:00
|
|
|
|
|
|
|
#if BOTH(HAS_COOLER, THERMAL_PROTECTION_COOLER)
|
|
|
|
#if TEMPDIR(COOLER) < 0
|
|
|
|
#define COOLERCMP(A,B) ((A)<(B))
|
|
|
|
#else
|
|
|
|
#define COOLERCMP(A,B) ((A)>(B))
|
|
|
|
#endif
|
|
|
|
if (cutter.unitPower > 0) {
|
|
|
|
if (COOLERCMP(temp_cooler.raw, maxtemp_raw_COOLER)) max_temp_error(H_COOLER);
|
|
|
|
}
|
|
|
|
if (COOLERCMP(mintemp_raw_COOLER, temp_cooler.raw)) min_temp_error(H_COOLER);
|
|
|
|
#endif
|
2018-07-26 08:59:19 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
static SoftPWM soft_pwm_cooler;
|
|
|
|
#endif
|
|
|
|
|
2021-01-07 03:32:30 +00:00
|
|
|
#define WRITE_FAN(n, v) WRITE(FAN##n##_PIN, (v) ^ FAN_INVERTING)
|
|
|
|
|
2015-07-31 05:29:30 +00:00
|
|
|
#if DISABLED(SLOW_PWM_HEATERS)
|
2019-09-10 07:20:49 +00:00
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if ANY(HAS_HOTEND, HAS_HEATED_BED, HAS_HEATED_CHAMBER, HAS_COOLER, FAN_SOFT_PWM)
|
2020-09-17 10:35:04 +00:00
|
|
|
constexpr uint8_t pwm_mask = TERN0(SOFT_PWM_DITHER, _BV(SOFT_PWM_SCALE) - 1);
|
2019-09-10 07:20:49 +00:00
|
|
|
#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
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
_PWM_MOD(COOLER,soft_pwm_cooler,temp_cooler);
|
|
|
|
#endif
|
|
|
|
|
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
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
_PWM_LOW(COOLER, soft_pwm_cooler);
|
|
|
|
#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
|
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
_SLOW_PWM(COOLER, soft_pwm_cooler, temp_cooler);
|
|
|
|
#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
|
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
_PWM_OFF(COOLER, soft_pwm_cooler, temp_cooler);
|
|
|
|
#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());
|
2021-03-06 20:13:28 +00:00
|
|
|
TERN_(HAS_COOLER, soft_pwm_cooler.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
|
|
|
|
2020-11-23 00:47:52 +00:00
|
|
|
#if HAS_TEMP_ADC_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
|
|
|
|
2020-11-23 00:47:52 +00:00
|
|
|
#if HAS_TEMP_ADC_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
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_TEMP_ADC_COOLER
|
|
|
|
case PrepareTemp_COOLER: HAL_START_ADC(TEMP_COOLER_PIN); break;
|
|
|
|
case MeasureTemp_COOLER: ACCUMULATE_ADC(temp_cooler); break;
|
|
|
|
#endif
|
|
|
|
|
2020-11-23 00:47:52 +00:00
|
|
|
#if HAS_TEMP_ADC_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) {
|
2021-03-06 20:13:28 +00:00
|
|
|
default:
|
|
|
|
#if HAS_TEMP_HOTEND
|
|
|
|
k = 'T'; break;
|
|
|
|
#endif
|
|
|
|
#if HAS_TEMP_BED
|
|
|
|
case H_BED: k = 'B'; break;
|
|
|
|
#endif
|
2019-06-28 02:29:53 +00:00
|
|
|
#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
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_TEMP_COOLER
|
|
|
|
case H_COOLER: k = 'L'; break;
|
|
|
|
#endif
|
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
|
|
|
case H_REDUNDANT: k = 'R'; break;
|
2019-06-28 02:29:53 +00:00
|
|
|
#endif
|
|
|
|
}
|
2021-01-05 12:18:09 +00:00
|
|
|
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
|
2021-01-05 12:18:09 +00:00
|
|
|
#ifdef SERIAL_FLOAT_PRECISION
|
|
|
|
#define SFP _MIN(SERIAL_FLOAT_PRECISION, 2)
|
|
|
|
#else
|
|
|
|
#define SFP 2
|
|
|
|
#endif
|
2019-02-24 04:53:01 +00:00
|
|
|
SERIAL_CHAR(':');
|
2021-01-05 12:18:09 +00:00
|
|
|
SERIAL_PRINT(c, SFP);
|
2021-01-05 05:57:58 +00:00
|
|
|
SERIAL_ECHOPGM(" /");
|
2021-01-05 12:18:09 +00:00
|
|
|
SERIAL_PRINT(t, SFP);
|
2017-09-16 09:44:37 +00:00
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
2021-02-09 01:51:57 +00:00
|
|
|
// Temperature MAX SPI boards do not have an OVERSAMPLENR defined
|
|
|
|
SERIAL_ECHOPAIR(" (", TERN(NO_THERMO_TEMPS, false, k == 'T') ? r : 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
|
2021-03-06 20:13:28 +00:00
|
|
|
print_heater_state(degChamber(), TERN0(HAS_HEATED_CHAMBER, degTargetChamber())
|
2019-05-05 03:51:47 +00:00
|
|
|
#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
|
|
|
);
|
2021-03-06 20:13:28 +00:00
|
|
|
#endif // HAS_TEMP_CHAMBER
|
|
|
|
#if HAS_TEMP_COOLER
|
|
|
|
print_heater_state(degCooler(), TERN0(HAS_COOLER, degTargetCooler())
|
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
|
|
|
, rawCoolerTemp()
|
|
|
|
#endif
|
|
|
|
, H_COOLER
|
|
|
|
);
|
|
|
|
#endif // HAS_TEMP_COOLER
|
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
|
|
|
|
);
|
2021-02-08 02:36:57 +00:00
|
|
|
#endif
|
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
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
SERIAL_ECHOPAIR(" C@:", getHeaterPower(H_COOLER));
|
|
|
|
#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)
|
2021-02-01 00:11:50 +00:00
|
|
|
AutoReporter<Temperature::AutoReportTemp> Temperature::auto_reporter;
|
|
|
|
void Temperature::AutoReportTemp::report() {
|
2021-01-29 02:40:20 +00:00
|
|
|
print_heater_states(active_extruder);
|
|
|
|
SERIAL_EOL();
|
2017-09-16 18:05:01 +00:00
|
|
|
}
|
2021-01-29 02:40:20 +00:00
|
|
|
#endif
|
2017-09-16 18:05:01 +00:00
|
|
|
|
2021-03-24 15:12:57 +00:00
|
|
|
#if HAS_HOTEND && HAS_STATUS_MESSAGE
|
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;
|
2021-01-29 02:40:20 +00:00
|
|
|
next_cool_check_ms = now + SEC_TO_MS(MIN_COOLING_SLOPE_TIME);
|
2018-09-29 06:44:47 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2021-02-25 14:28:27 +00:00
|
|
|
#if ENABLED(WAIT_FOR_HOTEND)
|
|
|
|
void Temperature::wait_for_hotend_heating(const uint8_t target_extruder) {
|
|
|
|
if (isHeatingHotend(target_extruder)) {
|
|
|
|
SERIAL_ECHOLNPGM("Wait for hotend heating...");
|
|
|
|
LCD_MESSAGEPGM(MSG_HEATING);
|
|
|
|
wait_for_hotend(target_extruder);
|
|
|
|
ui.reset_status();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
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;
|
2021-01-29 02:40:20 +00:00
|
|
|
next_cool_check_ms = now + SEC_TO_MS(MIN_COOLING_SLOPE_TIME_BED);
|
2018-09-29 06:44:47 +00:00
|
|
|
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;
|
|
|
|
}
|
2021-01-29 02:40:20 +00:00
|
|
|
next_delta_check_ms = now + SEC_TO_MS(MIN_DELTA_SLOPE_TIME_PROBE);
|
2020-09-12 03:51:19 +00:00
|
|
|
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
|
2020-10-06 23:36:01 +00:00
|
|
|
#define MIN_COOLING_SLOPE_TIME_CHAMBER 120
|
2019-05-05 03:51:47 +00:00
|
|
|
#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;
|
2021-01-29 02:40:20 +00:00
|
|
|
next_cool_check_ms = now + SEC_TO_MS(MIN_COOLING_SLOPE_TIME_CHAMBER);
|
2019-05-05 03:51:47 +00:00
|
|
|
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
|
|
|
|
|
2021-03-06 20:13:28 +00:00
|
|
|
#if HAS_COOLER
|
|
|
|
|
|
|
|
#ifndef MIN_COOLING_SLOPE_DEG_COOLER
|
|
|
|
#define MIN_COOLING_SLOPE_DEG_COOLER 1.50
|
|
|
|
#endif
|
|
|
|
#ifndef MIN_COOLING_SLOPE_TIME_COOLER
|
|
|
|
#define MIN_COOLING_SLOPE_TIME_COOLER 120
|
|
|
|
#endif
|
|
|
|
|
|
|
|
bool Temperature::wait_for_cooler(const bool no_wait_for_cooling/*=true*/) {
|
|
|
|
|
|
|
|
#if TEMP_COOLER_RESIDENCY_TIME > 0
|
|
|
|
millis_t residency_start_ms = 0;
|
|
|
|
bool first_loop = true;
|
|
|
|
// Loop until the temperature has stabilized
|
|
|
|
#define TEMP_COOLER_CONDITIONS (!residency_start_ms || PENDING(now, residency_start_ms + SEC_TO_MS(TEMP_COOLER_RESIDENCY_TIME)))
|
|
|
|
#else
|
|
|
|
// Loop until the temperature is very close target
|
|
|
|
#define TEMP_COOLER_CONDITIONS (wants_to_cool ? isLaserHeating() : isLaserCooling())
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if DISABLED(BUSY_WHILE_HEATING) && ENABLED(HOST_KEEPALIVE_FEATURE)
|
|
|
|
KEEPALIVE_STATE(NOT_BUSY);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
bool wants_to_cool = false;
|
|
|
|
float target_temp = -1, previous_temp = 9999;
|
|
|
|
millis_t now, next_temp_ms = 0, next_cooling_check_ms = 0;
|
|
|
|
wait_for_heatup = true;
|
|
|
|
do {
|
|
|
|
// Target temperature might be changed during the loop
|
|
|
|
if (target_temp != degTargetCooler()) {
|
|
|
|
wants_to_cool = isLaserHeating();
|
|
|
|
target_temp = degTargetCooler();
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
print_heater_states(active_extruder);
|
|
|
|
#if TEMP_COOLER_RESIDENCY_TIME > 0
|
|
|
|
SERIAL_ECHOPGM(" W:");
|
|
|
|
if (residency_start_ms)
|
|
|
|
SERIAL_ECHO(long((SEC_TO_MS(TEMP_COOLER_RESIDENCY_TIME) - (now - residency_start_ms)) / 1000UL));
|
|
|
|
else
|
|
|
|
SERIAL_CHAR('?');
|
|
|
|
#endif
|
|
|
|
SERIAL_EOL();
|
|
|
|
}
|
|
|
|
|
|
|
|
idle();
|
|
|
|
gcode.reset_stepper_timeout(); // Keep steppers powered
|
|
|
|
|
|
|
|
const float current_temp = degCooler();
|
|
|
|
|
|
|
|
#if TEMP_COOLER_RESIDENCY_TIME > 0
|
|
|
|
|
|
|
|
const float temp_diff = ABS(target_temp - temp);
|
|
|
|
|
|
|
|
if (!residency_start_ms) {
|
|
|
|
// Start the TEMP_COOLER_RESIDENCY_TIME timer when we reach target temp for the first time.
|
|
|
|
if (temp_diff < TEMP_COOLER_WINDOW)
|
|
|
|
residency_start_ms = now + (first_loop ? SEC_TO_MS(TEMP_COOLER_RESIDENCY_TIME) / 3 : 0);
|
|
|
|
}
|
|
|
|
else if (temp_diff > TEMP_COOLER_HYSTERESIS) {
|
|
|
|
// Restart the timer whenever the temperature falls outside the hysteresis.
|
|
|
|
residency_start_ms = now;
|
|
|
|
}
|
|
|
|
|
|
|
|
first_loop = false;
|
|
|
|
#endif // TEMP_COOLER_RESIDENCY_TIME > 0
|
|
|
|
|
|
|
|
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_cooling_check_ms || ELAPSED(now, next_cooling_check_ms)) {
|
|
|
|
if (previous_temp - current_temp < float(MIN_COOLING_SLOPE_DEG_COOLER)) break;
|
|
|
|
next_cooling_check_ms = now + SEC_TO_MS(MIN_COOLING_SLOPE_TIME_COOLER);
|
|
|
|
previous_temp = current_temp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} while (wait_for_heatup && TEMP_COOLER_CONDITIONS);
|
|
|
|
|
|
|
|
// Prevent a wait-forever situation if R is misused i.e. M191 R0
|
|
|
|
if (wait_for_heatup) {
|
|
|
|
wait_for_heatup = false;
|
|
|
|
ui.reset_status();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // HAS_COOLER
|
|
|
|
|
2018-03-07 07:53:50 +00:00
|
|
|
#endif // HAS_TEMP_SENSOR
|