2011-11-15 15:50:43 -06:00
|
|
|
/*
|
2015-04-02 07:10:14 -05:00
|
|
|
temperature.cpp - temperature control
|
2011-11-15 15:50:43 -06:00
|
|
|
Part of Marlin
|
|
|
|
|
|
|
|
Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2015-04-02 07:10:14 -05:00
|
|
|
*/
|
2011-12-22 05:38:50 -06:00
|
|
|
|
2011-11-15 15:50:43 -06:00
|
|
|
#include "Marlin.h"
|
|
|
|
#include "ultralcd.h"
|
|
|
|
#include "temperature.h"
|
|
|
|
#include "watchdog.h"
|
2015-02-25 01:03:08 -06:00
|
|
|
#include "language.h"
|
2011-11-15 15:50:43 -06:00
|
|
|
|
2015-01-15 17:52:10 -06:00
|
|
|
#include "Sd2PinMap.h"
|
|
|
|
|
2015-02-26 02:33:30 -06:00
|
|
|
//===========================================================================
|
|
|
|
//================================== macros =================================
|
|
|
|
//===========================================================================
|
|
|
|
|
2015-03-20 00:22:23 -05:00
|
|
|
#ifdef K1 // Defined in Configuration.h in the PID settings
|
|
|
|
#define K2 (1.0-K1)
|
2015-02-26 02:33:30 -06:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMPBED) || ENABLED(PIDTEMP)
|
2015-03-25 05:51:41 -05:00
|
|
|
#define PID_dT ((OVERSAMPLENR * 12.0)/(F_CPU / 64.0 / 256.0))
|
|
|
|
#endif
|
|
|
|
|
2011-11-15 15:50:43 -06:00
|
|
|
//===========================================================================
|
2015-01-25 10:56:14 -06:00
|
|
|
//============================= public variables ============================
|
2011-11-15 15:50:43 -06:00
|
|
|
//===========================================================================
|
2015-01-25 10:56:14 -06:00
|
|
|
|
2015-03-27 18:11:28 -05:00
|
|
|
int target_temperature[4] = { 0 };
|
2012-12-09 16:00:06 -06:00
|
|
|
int target_temperature_bed = 0;
|
2015-03-27 18:11:28 -05:00
|
|
|
int current_temperature_raw[4] = { 0 };
|
|
|
|
float current_temperature[4] = { 0.0 };
|
2012-12-09 16:00:06 -06:00
|
|
|
int current_temperature_bed_raw = 0;
|
2013-06-06 17:49:25 -05:00
|
|
|
float current_temperature_bed = 0.0;
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2013-06-06 17:49:25 -05:00
|
|
|
int redundant_temperature_raw = 0;
|
|
|
|
float redundant_temperature = 0.0;
|
|
|
|
#endif
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2012-09-12 21:01:31 -05:00
|
|
|
float bedKp=DEFAULT_bedKp;
|
|
|
|
float bedKi=(DEFAULT_bedKi*PID_dT);
|
|
|
|
float bedKd=(DEFAULT_bedKd/PID_dT);
|
|
|
|
#endif //PIDTEMPBED
|
2011-11-15 15:50:43 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
2013-06-09 05:52:49 -05:00
|
|
|
unsigned char fanSpeedSoftPwm;
|
|
|
|
#endif
|
2013-11-27 19:23:06 -06:00
|
|
|
|
|
|
|
unsigned char soft_pwm_bed;
|
2011-11-15 15:50:43 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(BABYSTEPPING)
|
2015-02-24 06:46:11 -06:00
|
|
|
volatile int babystepsTodo[3] = { 0 };
|
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 14:14:51 -05:00
|
|
|
#endif
|
2014-08-06 19:30:57 -05:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(FILAMENT_SENSOR)
|
2014-08-06 19:30:57 -05:00
|
|
|
int current_raw_filwidth = 0; //Holds measured filament diameter - one extruder only
|
|
|
|
#endif
|
2015-03-31 03:41:24 -05:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS) || ENABLED(THERMAL_PROTECTION_BED)
|
2015-04-04 07:45:36 -05:00
|
|
|
enum TRState { TRReset, TRInactive, TRFirstHeating, TRStable, TRRunaway };
|
2015-04-12 20:07:08 -05:00
|
|
|
void thermal_runaway_protection(TRState *state, millis_t *timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc);
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS)
|
2015-04-04 07:45:36 -05:00
|
|
|
static TRState thermal_runaway_state_machine[4] = { TRReset, TRReset, TRReset, TRReset };
|
2015-04-12 20:07:08 -05:00
|
|
|
static millis_t thermal_runaway_timer[4]; // = {0,0,0,0};
|
2015-03-31 03:41:24 -05:00
|
|
|
#endif
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_BED) && TEMP_SENSOR_BED != 0
|
2015-04-04 07:45:36 -05:00
|
|
|
static TRState thermal_runaway_bed_state_machine = TRReset;
|
2015-04-12 20:07:08 -05:00
|
|
|
static millis_t thermal_runaway_bed_timer;
|
2015-03-31 03:41:24 -05:00
|
|
|
#endif
|
2015-03-29 18:58:46 -05:00
|
|
|
#endif
|
|
|
|
|
2011-11-15 15:50:43 -06:00
|
|
|
//===========================================================================
|
2015-04-26 20:44:01 -05:00
|
|
|
//============================ private variables ============================
|
2011-11-15 15:50:43 -06:00
|
|
|
//===========================================================================
|
2015-04-26 20:44:01 -05:00
|
|
|
|
2012-03-08 14:43:21 -06:00
|
|
|
static volatile bool temp_meas_ready = false;
|
2011-11-15 15:50:43 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
2011-11-15 15:50:43 -06:00
|
|
|
//static cannot be external:
|
2011-12-05 22:33:33 -06:00
|
|
|
static float temp_iState[EXTRUDERS] = { 0 };
|
|
|
|
static float temp_dState[EXTRUDERS] = { 0 };
|
|
|
|
static float pTerm[EXTRUDERS];
|
|
|
|
static float iTerm[EXTRUDERS];
|
|
|
|
static float dTerm[EXTRUDERS];
|
2015-08-30 21:04:30 -05:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
|
|
|
static float cTerm[EXTRUDERS];
|
|
|
|
static long last_position[EXTRUDERS];
|
|
|
|
static long lpq[LPQ_MAX_LEN];
|
|
|
|
static int lpq_ptr = 0;
|
|
|
|
#endif
|
2011-11-15 15:50:43 -06:00
|
|
|
//int output;
|
2011-12-05 22:33:33 -06:00
|
|
|
static float pid_error[EXTRUDERS];
|
|
|
|
static float temp_iState_min[EXTRUDERS];
|
|
|
|
static float temp_iState_max[EXTRUDERS];
|
|
|
|
static bool pid_reset[EXTRUDERS];
|
2011-11-15 15:50:43 -06:00
|
|
|
#endif //PIDTEMP
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2012-09-12 21:01:31 -05:00
|
|
|
//static cannot be external:
|
|
|
|
static float temp_iState_bed = { 0 };
|
|
|
|
static float temp_dState_bed = { 0 };
|
|
|
|
static float pTerm_bed;
|
|
|
|
static float iTerm_bed;
|
|
|
|
static float dTerm_bed;
|
|
|
|
//int output;
|
|
|
|
static float pid_error_bed;
|
|
|
|
static float temp_iState_min_bed;
|
|
|
|
static float temp_iState_max_bed;
|
2012-09-17 19:18:09 -05:00
|
|
|
#else //PIDTEMPBED
|
2015-04-13 01:06:50 -05:00
|
|
|
static millis_t next_bed_check_ms;
|
2012-09-12 21:01:31 -05:00
|
|
|
#endif //PIDTEMPBED
|
2011-12-12 12:34:37 -06:00
|
|
|
static unsigned char soft_pwm[EXTRUDERS];
|
2013-11-27 19:23:06 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
2012-12-15 18:36:57 -06:00
|
|
|
static unsigned char soft_pwm_fan;
|
|
|
|
#endif
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN
|
2015-04-13 01:06:50 -05:00
|
|
|
static millis_t next_auto_fan_check_ms;
|
2013-06-06 17:49:25 -05:00
|
|
|
#endif
|
2012-12-15 18:36:57 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
|
|
|
#if ENABLED(PID_PARAMS_PER_EXTRUDER)
|
2015-07-23 20:24:37 -05:00
|
|
|
float Kp[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(DEFAULT_Kp);
|
|
|
|
float Ki[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(DEFAULT_Ki*PID_dT);
|
|
|
|
float Kd[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(DEFAULT_Kd / PID_dT);
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-07-23 20:24:37 -05:00
|
|
|
float Kc[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(DEFAULT_Kc);
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif // PID_ADD_EXTRUSION_RATE
|
|
|
|
#else //PID_PARAMS_PER_EXTRUDER
|
|
|
|
float Kp = DEFAULT_Kp;
|
|
|
|
float Ki = DEFAULT_Ki * PID_dT;
|
|
|
|
float Kd = DEFAULT_Kd / PID_dT;
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-02-24 06:46:11 -06:00
|
|
|
float Kc = DEFAULT_Kc;
|
|
|
|
#endif // PID_ADD_EXTRUSION_RATE
|
|
|
|
#endif // PID_PARAMS_PER_EXTRUDER
|
Independent PID parameters for each extruder
* Variables Kp, Ki, Kd, Kc now arrays of size EXTRUDERS
* M301 gains (optional, default=0) E parameter to define which
extruder's settings to modify. Tested, works with Repetier Host's EEPROM
config window, albeit only reads/updates settings for E0.
* All Kp, Ki, Kd, Kc parameters saved in EEPROM (version now v14), up to
3 extruders supported (same as Marlin in general)
2015-01-09 21:46:08 -06:00
|
|
|
#endif //PIDTEMP
|
|
|
|
|
2012-12-05 12:54:01 -06:00
|
|
|
// Init min and max temp with extreme values to prevent false errors during startup
|
2015-01-23 16:13:06 -06:00
|
|
|
static int minttemp_raw[EXTRUDERS] = ARRAY_BY_EXTRUDERS( HEATER_0_RAW_LO_TEMP , HEATER_1_RAW_LO_TEMP , HEATER_2_RAW_LO_TEMP, HEATER_3_RAW_LO_TEMP);
|
|
|
|
static int maxttemp_raw[EXTRUDERS] = ARRAY_BY_EXTRUDERS( HEATER_0_RAW_HI_TEMP , HEATER_1_RAW_HI_TEMP , HEATER_2_RAW_HI_TEMP, HEATER_3_RAW_HI_TEMP);
|
2015-03-23 22:55:48 -05:00
|
|
|
static int minttemp[EXTRUDERS] = { 0 };
|
2015-07-23 20:24:37 -05:00
|
|
|
static int maxttemp[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(16383);
|
2015-05-25 06:23:19 -05:00
|
|
|
#ifdef BED_MINTEMP
|
|
|
|
static int bed_minttemp_raw = HEATER_BED_RAW_LO_TEMP;
|
|
|
|
#endif
|
2012-12-09 16:00:06 -06:00
|
|
|
#ifdef BED_MAXTEMP
|
2015-02-24 06:46:11 -06:00
|
|
|
static int bed_maxttemp_raw = HEATER_BED_RAW_HI_TEMP;
|
2012-12-09 16:00:06 -06:00
|
|
|
#endif
|
2013-06-06 17:49:25 -05:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2013-06-06 17:49:25 -05:00
|
|
|
static void *heater_ttbl_map[2] = {(void *)HEATER_0_TEMPTABLE, (void *)HEATER_1_TEMPTABLE };
|
|
|
|
static uint8_t heater_ttbllen_map[2] = { HEATER_0_TEMPTABLE_LEN, HEATER_1_TEMPTABLE_LEN };
|
|
|
|
#else
|
2015-01-23 16:13:06 -06:00
|
|
|
static void *heater_ttbl_map[EXTRUDERS] = ARRAY_BY_EXTRUDERS( (void *)HEATER_0_TEMPTABLE, (void *)HEATER_1_TEMPTABLE, (void *)HEATER_2_TEMPTABLE, (void *)HEATER_3_TEMPTABLE );
|
|
|
|
static uint8_t heater_ttbllen_map[EXTRUDERS] = ARRAY_BY_EXTRUDERS( HEATER_0_TEMPTABLE_LEN, HEATER_1_TEMPTABLE_LEN, HEATER_2_TEMPTABLE_LEN, HEATER_3_TEMPTABLE_LEN );
|
2013-06-06 17:49:25 -05:00
|
|
|
#endif
|
2012-12-09 16:00:06 -06:00
|
|
|
|
|
|
|
static float analog2temp(int raw, uint8_t e);
|
|
|
|
static float analog2tempBed(int raw);
|
|
|
|
static void updateTemperaturesFromRawValues();
|
2012-12-05 12:54:01 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS)
|
2015-05-09 00:36:02 -05:00
|
|
|
int watch_target_temp[EXTRUDERS] = { 0 };
|
2015-05-09 00:25:51 -05:00
|
|
|
millis_t watch_heater_next_ms[EXTRUDERS] = { 0 };
|
|
|
|
#endif
|
2011-11-15 15:50:43 -06:00
|
|
|
|
2013-06-09 05:52:49 -05:00
|
|
|
#ifndef SOFT_PWM_SCALE
|
2015-02-24 06:46:11 -06:00
|
|
|
#define SOFT_PWM_SCALE 0
|
2013-06-09 05:52:49 -05:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(FILAMENT_SENSOR)
|
2014-08-06 19:30:57 -05:00
|
|
|
static int meas_shift_index; //used to point to a delayed sample in buffer for filament width sensor
|
|
|
|
#endif
|
2015-01-23 12:37:39 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(HEATER_0_USES_MAX6675)
|
2015-01-23 12:37:39 -06:00
|
|
|
static int read_max6675();
|
|
|
|
#endif
|
|
|
|
|
2011-11-15 15:50:43 -06:00
|
|
|
//===========================================================================
|
2015-04-28 00:25:00 -05:00
|
|
|
//================================ Functions ================================
|
2011-11-15 15:50:43 -06:00
|
|
|
//===========================================================================
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2015-06-10 01:27:56 -05:00
|
|
|
void PID_autotune(float temp, int extruder, int ncycles) {
|
2012-11-06 05:06:41 -06:00
|
|
|
float input = 0.0;
|
2015-02-24 06:46:11 -06:00
|
|
|
int cycles = 0;
|
2012-03-08 14:43:21 -06:00
|
|
|
bool heating = true;
|
|
|
|
|
2015-04-12 20:07:08 -05:00
|
|
|
millis_t temp_ms = millis(), t1 = temp_ms, t2 = temp_ms;
|
2015-02-24 06:46:11 -06:00
|
|
|
long t_high = 0, t_low = 0;
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2012-09-17 14:17:24 -05:00
|
|
|
long bias, d;
|
2012-03-08 14:43:21 -06:00
|
|
|
float Ku, Tu;
|
|
|
|
float Kp, Ki, Kd;
|
2012-11-06 05:06:41 -06:00
|
|
|
float max = 0, min = 10000;
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN
|
2015-04-13 01:06:50 -05:00
|
|
|
millis_t next_auto_fan_check_ms = temp_ms + 2500;
|
2013-06-06 17:49:25 -05:00
|
|
|
#endif
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
if (extruder >= EXTRUDERS
|
|
|
|
#if !HAS_TEMP_BED
|
|
|
|
|| extruder < 0
|
|
|
|
#endif
|
|
|
|
) {
|
2015-02-25 01:03:08 -06:00
|
|
|
SERIAL_ECHOLN(MSG_PID_BAD_EXTRUDER_NUM);
|
2015-02-24 06:46:11 -06:00
|
|
|
return;
|
2012-09-17 14:17:24 -05:00
|
|
|
}
|
2015-03-21 16:23:43 -05:00
|
|
|
|
2015-02-25 01:03:08 -06:00
|
|
|
SERIAL_ECHOLN(MSG_PID_AUTOTUNE_START);
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2015-04-13 19:17:36 -05:00
|
|
|
disable_all_heaters(); // switch off all heaters.
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
if (extruder < 0)
|
|
|
|
soft_pwm_bed = bias = d = MAX_BED_POWER / 2;
|
|
|
|
else
|
|
|
|
soft_pwm[extruder] = bias = d = PID_MAX / 2;
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// PID Tuning loop
|
2015-04-02 07:10:14 -05:00
|
|
|
for (;;) {
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2015-04-12 20:07:08 -05:00
|
|
|
millis_t ms = millis();
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2015-03-26 18:22:21 -05:00
|
|
|
if (temp_meas_ready) { // temp sample ready
|
2012-12-09 16:00:06 -06:00
|
|
|
updateTemperaturesFromRawValues();
|
|
|
|
|
|
|
|
input = (extruder<0)?current_temperature_bed:current_temperature[extruder];
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
max = max(max, input);
|
|
|
|
min = min(min, input);
|
2014-12-23 22:35:54 -06:00
|
|
|
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN
|
2015-04-13 01:06:50 -05:00
|
|
|
if (ms > next_auto_fan_check_ms) {
|
2015-02-24 06:46:11 -06:00
|
|
|
checkExtruderAutoFans();
|
2015-04-13 01:06:50 -05:00
|
|
|
next_auto_fan_check_ms = ms + 2500;
|
2015-02-24 06:46:11 -06:00
|
|
|
}
|
2014-12-23 22:35:54 -06:00
|
|
|
#endif
|
|
|
|
|
2015-05-13 04:02:19 -05:00
|
|
|
if (heating && input > temp) {
|
|
|
|
if (ms > t2 + 5000) {
|
2015-02-24 06:46:11 -06:00
|
|
|
heating = false;
|
|
|
|
if (extruder < 0)
|
2013-06-06 17:49:25 -05:00
|
|
|
soft_pwm_bed = (bias - d) >> 1;
|
|
|
|
else
|
|
|
|
soft_pwm[extruder] = (bias - d) >> 1;
|
2015-02-24 06:46:11 -06:00
|
|
|
t1 = ms;
|
|
|
|
t_high = t1 - t2;
|
|
|
|
max = temp;
|
2012-03-08 14:43:21 -06:00
|
|
|
}
|
|
|
|
}
|
2015-05-13 04:02:19 -05:00
|
|
|
|
|
|
|
if (!heating && input < temp) {
|
|
|
|
if (ms > t1 + 5000) {
|
2015-02-24 06:46:11 -06:00
|
|
|
heating = true;
|
|
|
|
t2 = ms;
|
|
|
|
t_low = t2 - t1;
|
|
|
|
if (cycles > 0) {
|
|
|
|
long max_pow = extruder < 0 ? MAX_BED_POWER : PID_MAX;
|
2012-03-08 14:43:21 -06:00
|
|
|
bias += (d*(t_high - t_low))/(t_low + t_high);
|
2015-02-24 06:46:11 -06:00
|
|
|
bias = constrain(bias, 20, max_pow - 20);
|
|
|
|
d = (bias > max_pow / 2) ? max_pow - 1 - bias : bias;
|
2012-03-08 14:43:21 -06:00
|
|
|
|
2015-02-25 01:03:08 -06:00
|
|
|
SERIAL_PROTOCOLPGM(MSG_BIAS); SERIAL_PROTOCOL(bias);
|
|
|
|
SERIAL_PROTOCOLPGM(MSG_D); SERIAL_PROTOCOL(d);
|
2015-03-05 17:25:44 -06:00
|
|
|
SERIAL_PROTOCOLPGM(MSG_T_MIN); SERIAL_PROTOCOL(min);
|
|
|
|
SERIAL_PROTOCOLPGM(MSG_T_MAX); SERIAL_PROTOCOLLN(max);
|
2015-02-24 06:46:11 -06:00
|
|
|
if (cycles > 2) {
|
|
|
|
Ku = (4.0 * d) / (3.14159265 * (max - min) / 2.0);
|
|
|
|
Tu = ((float)(t_low + t_high) / 1000.0);
|
2015-02-25 01:03:08 -06:00
|
|
|
SERIAL_PROTOCOLPGM(MSG_KU); SERIAL_PROTOCOL(Ku);
|
|
|
|
SERIAL_PROTOCOLPGM(MSG_TU); SERIAL_PROTOCOLLN(Tu);
|
2015-02-24 06:46:11 -06:00
|
|
|
Kp = 0.6 * Ku;
|
|
|
|
Ki = 2 * Kp / Tu;
|
|
|
|
Kd = Kp * Tu / 8;
|
2015-02-25 01:03:08 -06:00
|
|
|
SERIAL_PROTOCOLLNPGM(MSG_CLASSIC_PID);
|
|
|
|
SERIAL_PROTOCOLPGM(MSG_KP); SERIAL_PROTOCOLLN(Kp);
|
|
|
|
SERIAL_PROTOCOLPGM(MSG_KI); SERIAL_PROTOCOLLN(Ki);
|
|
|
|
SERIAL_PROTOCOLPGM(MSG_KD); SERIAL_PROTOCOLLN(Kd);
|
2012-04-15 12:17:33 -05:00
|
|
|
/*
|
2012-03-11 16:18:25 -05:00
|
|
|
Kp = 0.33*Ku;
|
|
|
|
Ki = Kp/Tu;
|
|
|
|
Kd = Kp*Tu/3;
|
2014-04-25 03:05:05 -05:00
|
|
|
SERIAL_PROTOCOLLNPGM(" Some overshoot ");
|
2012-03-11 16:18:25 -05:00
|
|
|
SERIAL_PROTOCOLPGM(" Kp: "); SERIAL_PROTOCOLLN(Kp);
|
|
|
|
SERIAL_PROTOCOLPGM(" Ki: "); SERIAL_PROTOCOLLN(Ki);
|
|
|
|
SERIAL_PROTOCOLPGM(" Kd: "); SERIAL_PROTOCOLLN(Kd);
|
|
|
|
Kp = 0.2*Ku;
|
|
|
|
Ki = 2*Kp/Tu;
|
|
|
|
Kd = Kp*Tu/3;
|
2014-04-25 03:05:05 -05:00
|
|
|
SERIAL_PROTOCOLLNPGM(" No overshoot ");
|
2012-03-08 14:43:21 -06:00
|
|
|
SERIAL_PROTOCOLPGM(" Kp: "); SERIAL_PROTOCOLLN(Kp);
|
|
|
|
SERIAL_PROTOCOLPGM(" Ki: "); SERIAL_PROTOCOLLN(Ki);
|
|
|
|
SERIAL_PROTOCOLPGM(" Kd: "); SERIAL_PROTOCOLLN(Kd);
|
2012-04-15 12:17:33 -05:00
|
|
|
*/
|
2012-03-08 14:43:21 -06:00
|
|
|
}
|
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
if (extruder < 0)
|
2013-06-06 17:49:25 -05:00
|
|
|
soft_pwm_bed = (bias + d) >> 1;
|
|
|
|
else
|
|
|
|
soft_pwm[extruder] = (bias + d) >> 1;
|
2012-03-08 14:43:21 -06:00
|
|
|
cycles++;
|
2015-02-24 06:46:11 -06:00
|
|
|
min = temp;
|
2012-03-08 14:43:21 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-05-18 07:15:29 -05:00
|
|
|
#define MAX_OVERSHOOT_PID_AUTOTUNE 20
|
|
|
|
if (input > temp + MAX_OVERSHOOT_PID_AUTOTUNE) {
|
2015-02-25 01:03:08 -06:00
|
|
|
SERIAL_PROTOCOLLNPGM(MSG_PID_TEMP_TOO_HIGH);
|
2012-03-08 14:43:21 -06:00
|
|
|
return;
|
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
// Every 2 seconds...
|
2015-04-12 20:07:08 -05:00
|
|
|
if (ms > temp_ms + 2000) {
|
2013-06-06 17:49:25 -05:00
|
|
|
int p;
|
2015-02-24 06:46:11 -06:00
|
|
|
if (extruder < 0) {
|
|
|
|
p = soft_pwm_bed;
|
2015-06-10 01:27:56 -05:00
|
|
|
SERIAL_PROTOCOLPGM(MSG_B);
|
2015-02-24 06:46:11 -06:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
p = soft_pwm[extruder];
|
2015-06-10 01:27:56 -05:00
|
|
|
SERIAL_PROTOCOLPGM(MSG_T);
|
2013-06-06 17:49:25 -05:00
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
|
|
|
|
SERIAL_PROTOCOL(input);
|
2015-02-25 01:03:08 -06:00
|
|
|
SERIAL_PROTOCOLPGM(MSG_AT);
|
2015-02-24 06:46:11 -06:00
|
|
|
SERIAL_PROTOCOLLN(p);
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2015-04-12 20:07:08 -05:00
|
|
|
temp_ms = ms;
|
2015-02-24 06:46:11 -06:00
|
|
|
} // every 2 seconds
|
|
|
|
// Over 2 minutes?
|
|
|
|
if (((ms - t1) + (ms - t2)) > (10L*60L*1000L*2L)) {
|
2015-02-25 01:03:08 -06:00
|
|
|
SERIAL_PROTOCOLLNPGM(MSG_PID_TIMEOUT);
|
2012-04-15 12:17:33 -05:00
|
|
|
return;
|
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
if (cycles > ncycles) {
|
2015-02-25 01:03:08 -06:00
|
|
|
SERIAL_PROTOCOLLNPGM(MSG_PID_AUTOTUNE_FINISHED);
|
2015-04-28 00:25:00 -05:00
|
|
|
const char *estring = extruder < 0 ? "bed" : "";
|
|
|
|
SERIAL_PROTOCOLPGM("#define DEFAULT_"); SERIAL_PROTOCOL(estring); SERIAL_PROTOCOLPGM("Kp "); SERIAL_PROTOCOLLN(Kp);
|
|
|
|
SERIAL_PROTOCOLPGM("#define DEFAULT_"); SERIAL_PROTOCOL(estring); SERIAL_PROTOCOLPGM("Ki "); SERIAL_PROTOCOLLN(Ki);
|
|
|
|
SERIAL_PROTOCOLPGM("#define DEFAULT_"); SERIAL_PROTOCOL(estring); SERIAL_PROTOCOLPGM("Kd "); SERIAL_PROTOCOLLN(Kd);
|
2012-04-15 12:17:33 -05:00
|
|
|
return;
|
|
|
|
}
|
2012-12-03 05:52:00 -06:00
|
|
|
lcd_update();
|
2012-03-08 14:43:21 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
void updatePID() {
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
2015-02-24 06:46:11 -06:00
|
|
|
for (int e = 0; e < EXTRUDERS; e++) {
|
|
|
|
temp_iState_max[e] = PID_INTEGRAL_DRIVE_MAX / PID_PARAM(Ki,e);
|
2015-08-30 21:04:30 -05:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
|
|
|
last_position[e] = 0;
|
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
}
|
|
|
|
#endif
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2015-05-28 10:30:56 -05:00
|
|
|
temp_iState_max_bed = PID_BED_INTEGRAL_DRIVE_MAX / bedKi;
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
2011-11-15 15:50:43 -06:00
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
|
2011-12-12 12:34:37 -06:00
|
|
|
int getHeaterPower(int heater) {
|
2015-02-24 06:46:11 -06:00
|
|
|
return heater < 0 ? soft_pwm_bed : soft_pwm[heater];
|
2011-12-12 12:34:37 -06:00
|
|
|
}
|
|
|
|
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN
|
2013-06-06 17:49:25 -05:00
|
|
|
|
2015-06-09 19:01:47 -05:00
|
|
|
void setExtruderAutoFanState(int pin, bool state) {
|
2013-06-06 17:49:25 -05:00
|
|
|
unsigned char newFanSpeed = (state != 0) ? EXTRUDER_AUTO_FAN_SPEED : 0;
|
|
|
|
// this idiom allows both digital and PWM fan outputs (see M42 handling).
|
|
|
|
digitalWrite(pin, newFanSpeed);
|
|
|
|
analogWrite(pin, newFanSpeed);
|
|
|
|
}
|
|
|
|
|
2015-06-09 19:01:47 -05:00
|
|
|
void checkExtruderAutoFans() {
|
2013-06-06 17:49:25 -05:00
|
|
|
uint8_t fanState = 0;
|
|
|
|
|
|
|
|
// which fan pins need to be turned on?
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN_0
|
2013-06-06 17:49:25 -05:00
|
|
|
if (current_temperature[0] > EXTRUDER_AUTO_FAN_TEMPERATURE)
|
|
|
|
fanState |= 1;
|
|
|
|
#endif
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN_1
|
2013-06-06 17:49:25 -05:00
|
|
|
if (current_temperature[1] > EXTRUDER_AUTO_FAN_TEMPERATURE)
|
|
|
|
{
|
2015-02-26 03:14:59 -06:00
|
|
|
if (EXTRUDER_1_AUTO_FAN_PIN == EXTRUDER_0_AUTO_FAN_PIN)
|
2013-06-06 17:49:25 -05:00
|
|
|
fanState |= 1;
|
|
|
|
else
|
|
|
|
fanState |= 2;
|
|
|
|
}
|
|
|
|
#endif
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN_2
|
2013-06-06 17:49:25 -05:00
|
|
|
if (current_temperature[2] > EXTRUDER_AUTO_FAN_TEMPERATURE)
|
|
|
|
{
|
|
|
|
if (EXTRUDER_2_AUTO_FAN_PIN == EXTRUDER_0_AUTO_FAN_PIN)
|
|
|
|
fanState |= 1;
|
|
|
|
else if (EXTRUDER_2_AUTO_FAN_PIN == EXTRUDER_1_AUTO_FAN_PIN)
|
|
|
|
fanState |= 2;
|
|
|
|
else
|
|
|
|
fanState |= 4;
|
|
|
|
}
|
|
|
|
#endif
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN_3
|
2015-01-23 16:13:06 -06:00
|
|
|
if (current_temperature[3] > EXTRUDER_AUTO_FAN_TEMPERATURE)
|
|
|
|
{
|
|
|
|
if (EXTRUDER_3_AUTO_FAN_PIN == EXTRUDER_0_AUTO_FAN_PIN)
|
|
|
|
fanState |= 1;
|
|
|
|
else if (EXTRUDER_3_AUTO_FAN_PIN == EXTRUDER_1_AUTO_FAN_PIN)
|
|
|
|
fanState |= 2;
|
|
|
|
else if (EXTRUDER_3_AUTO_FAN_PIN == EXTRUDER_2_AUTO_FAN_PIN)
|
|
|
|
fanState |= 4;
|
|
|
|
else
|
|
|
|
fanState |= 8;
|
|
|
|
}
|
|
|
|
#endif
|
2013-06-06 17:49:25 -05:00
|
|
|
|
|
|
|
// update extruder auto fan states
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN_0
|
2013-06-06 17:49:25 -05:00
|
|
|
setExtruderAutoFanState(EXTRUDER_0_AUTO_FAN_PIN, (fanState & 1) != 0);
|
2015-06-12 06:12:55 -05:00
|
|
|
#endif
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN_1
|
2015-02-20 02:08:59 -06:00
|
|
|
if (EXTRUDER_1_AUTO_FAN_PIN != EXTRUDER_0_AUTO_FAN_PIN)
|
2013-06-06 17:49:25 -05:00
|
|
|
setExtruderAutoFanState(EXTRUDER_1_AUTO_FAN_PIN, (fanState & 2) != 0);
|
2015-06-12 06:12:55 -05:00
|
|
|
#endif
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN_2
|
2015-02-20 02:08:59 -06:00
|
|
|
if (EXTRUDER_2_AUTO_FAN_PIN != EXTRUDER_0_AUTO_FAN_PIN
|
2013-06-06 17:49:25 -05:00
|
|
|
&& EXTRUDER_2_AUTO_FAN_PIN != EXTRUDER_1_AUTO_FAN_PIN)
|
|
|
|
setExtruderAutoFanState(EXTRUDER_2_AUTO_FAN_PIN, (fanState & 4) != 0);
|
2015-01-23 16:13:06 -06:00
|
|
|
#endif
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN_3
|
2015-02-20 02:08:59 -06:00
|
|
|
if (EXTRUDER_3_AUTO_FAN_PIN != EXTRUDER_0_AUTO_FAN_PIN
|
|
|
|
&& EXTRUDER_3_AUTO_FAN_PIN != EXTRUDER_1_AUTO_FAN_PIN
|
2015-02-08 02:05:05 -06:00
|
|
|
&& EXTRUDER_3_AUTO_FAN_PIN != EXTRUDER_2_AUTO_FAN_PIN)
|
2015-01-23 16:13:06 -06:00
|
|
|
setExtruderAutoFanState(EXTRUDER_3_AUTO_FAN_PIN, (fanState & 8) != 0);
|
|
|
|
#endif
|
2013-06-06 17:49:25 -05:00
|
|
|
}
|
|
|
|
|
2015-06-09 19:01:47 -05:00
|
|
|
#endif // HAS_AUTO_FAN
|
2013-06-06 17:49:25 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
//
|
2015-03-20 00:22:23 -05:00
|
|
|
// Temperature Error Handlers
|
2015-02-24 06:46:11 -06:00
|
|
|
//
|
2015-05-09 00:25:51 -05:00
|
|
|
inline void _temp_error(int e, const char *serial_msg, const char *lcd_msg) {
|
2015-05-25 05:44:03 -05:00
|
|
|
static bool killed = false;
|
2015-04-08 02:56:19 -05:00
|
|
|
if (IsRunning()) {
|
2015-03-11 18:38:42 -05:00
|
|
|
SERIAL_ERROR_START;
|
2015-05-09 00:25:51 -05:00
|
|
|
serialprintPGM(serial_msg);
|
2015-05-18 13:26:25 -05:00
|
|
|
SERIAL_ERRORPGM(MSG_STOPPED_HEATER);
|
|
|
|
if (e >= 0) SERIAL_ERRORLN((int)e); else SERIAL_ERRORLNPGM(MSG_HEATER_BED);
|
2015-03-11 18:38:42 -05:00
|
|
|
}
|
2015-07-31 00:29:30 -05:00
|
|
|
#if DISABLED(BOGUS_TEMPERATURE_FAILSAFE_OVERRIDE)
|
2015-05-25 05:44:03 -05:00
|
|
|
if (!killed) {
|
|
|
|
Running = false;
|
|
|
|
killed = true;
|
|
|
|
kill(lcd_msg);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
disable_all_heaters(); // paranoia
|
2015-03-11 18:38:42 -05:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void max_temp_error(uint8_t e) {
|
2015-05-18 13:26:25 -05:00
|
|
|
_temp_error(e, PSTR(MSG_T_MAXTEMP), PSTR(MSG_ERR_MAXTEMP));
|
2015-03-11 18:38:42 -05:00
|
|
|
}
|
|
|
|
void min_temp_error(uint8_t e) {
|
2015-05-18 13:26:25 -05:00
|
|
|
_temp_error(e, PSTR(MSG_T_MINTEMP), PSTR(MSG_ERR_MINTEMP));
|
2015-03-11 18:38:42 -05:00
|
|
|
}
|
|
|
|
|
2015-03-13 21:49:41 -05:00
|
|
|
float get_pid_output(int e) {
|
|
|
|
float pid_output;
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
|
|
|
#if DISABLED(PID_OPENLOOP)
|
2015-03-13 21:49:41 -05:00
|
|
|
pid_error[e] = target_temperature[e] - current_temperature[e];
|
2015-07-13 07:54:14 -05:00
|
|
|
dTerm[e] = K2 * PID_PARAM(Kd,e) * (current_temperature[e] - temp_dState[e]) + K1 * dTerm[e];
|
|
|
|
temp_dState[e] = current_temperature[e];
|
2015-03-13 21:49:41 -05:00
|
|
|
if (pid_error[e] > PID_FUNCTIONAL_RANGE) {
|
|
|
|
pid_output = BANG_MAX;
|
|
|
|
pid_reset[e] = true;
|
|
|
|
}
|
|
|
|
else if (pid_error[e] < -PID_FUNCTIONAL_RANGE || target_temperature[e] == 0) {
|
|
|
|
pid_output = 0;
|
|
|
|
pid_reset[e] = true;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (pid_reset[e]) {
|
|
|
|
temp_iState[e] = 0.0;
|
|
|
|
pid_reset[e] = false;
|
|
|
|
}
|
|
|
|
pTerm[e] = PID_PARAM(Kp,e) * pid_error[e];
|
|
|
|
temp_iState[e] += pid_error[e];
|
|
|
|
temp_iState[e] = constrain(temp_iState[e], temp_iState_min[e], temp_iState_max[e]);
|
|
|
|
iTerm[e] = PID_PARAM(Ki,e) * temp_iState[e];
|
|
|
|
|
|
|
|
pid_output = pTerm[e] + iTerm[e] - dTerm[e];
|
2015-08-30 21:04:30 -05:00
|
|
|
|
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
|
|
|
cTerm[e] = 0;
|
|
|
|
if (e == active_extruder) {
|
|
|
|
long e_position = st_get_position(E_AXIS);
|
|
|
|
if (e_position > last_position[e]) {
|
|
|
|
lpq[lpq_ptr++] = e_position - last_position[e];
|
|
|
|
last_position[e] = e_position;
|
|
|
|
} else {
|
|
|
|
lpq[lpq_ptr++] = 0;
|
|
|
|
}
|
|
|
|
if (lpq_ptr >= lpq_len) lpq_ptr = 0;
|
|
|
|
cTerm[e] = (lpq[lpq_ptr] / axis_steps_per_unit[E_AXIS]) * Kc;
|
|
|
|
pid_output += cTerm[e];
|
|
|
|
}
|
|
|
|
#endif //PID_ADD_EXTRUSION_RATE
|
|
|
|
|
2015-03-13 21:49:41 -05:00
|
|
|
if (pid_output > PID_MAX) {
|
|
|
|
if (pid_error[e] > 0) temp_iState[e] -= pid_error[e]; // conditional un-integration
|
|
|
|
pid_output = PID_MAX;
|
|
|
|
}
|
|
|
|
else if (pid_output < 0) {
|
|
|
|
if (pid_error[e] < 0) temp_iState[e] -= pid_error[e]; // conditional un-integration
|
|
|
|
pid_output = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
pid_output = constrain(target_temperature[e], 0, PID_MAX);
|
|
|
|
#endif //PID_OPENLOOP
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PID_DEBUG)
|
2015-03-13 21:49:41 -05:00
|
|
|
SERIAL_ECHO_START;
|
2015-08-30 21:04:30 -05:00
|
|
|
SERIAL_ECHOPAIR(MSG_PID_DEBUG, e);
|
|
|
|
SERIAL_ECHOPAIR(MSG_PID_DEBUG_INPUT, current_temperature[e]);
|
|
|
|
SERIAL_ECHOPAIR(MSG_PID_DEBUG_OUTPUT, pid_output);
|
|
|
|
SERIAL_ECHOPAIR(MSG_PID_DEBUG_PTERM, pTerm[e]);
|
|
|
|
SERIAL_ECHOPAIR(MSG_PID_DEBUG_ITERM, iTerm[e]);
|
|
|
|
SERIAL_ECHOPAIR(MSG_PID_DEBUG_DTERM, dTerm[e]);
|
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
|
|
|
SERIAL_ECHOPAIR(MSG_PID_DEBUG_CTERM, cTerm[e]);
|
|
|
|
#endif
|
|
|
|
SERIAL_EOL;
|
2015-03-13 21:49:41 -05:00
|
|
|
#endif //PID_DEBUG
|
|
|
|
|
|
|
|
#else /* PID off */
|
|
|
|
pid_output = (current_temperature[e] < target_temperature[e]) ? PID_MAX : 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return pid_output;
|
|
|
|
}
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2015-03-13 21:49:41 -05:00
|
|
|
float get_pid_output_bed() {
|
|
|
|
float pid_output;
|
2015-07-31 00:29:30 -05:00
|
|
|
#if DISABLED(PID_OPENLOOP)
|
2015-03-13 21:49:41 -05:00
|
|
|
pid_error_bed = target_temperature_bed - current_temperature_bed;
|
|
|
|
pTerm_bed = bedKp * pid_error_bed;
|
|
|
|
temp_iState_bed += pid_error_bed;
|
|
|
|
temp_iState_bed = constrain(temp_iState_bed, temp_iState_min_bed, temp_iState_max_bed);
|
|
|
|
iTerm_bed = bedKi * temp_iState_bed;
|
|
|
|
|
|
|
|
dTerm_bed = K2 * bedKd * (current_temperature_bed - temp_dState_bed) + K1 * dTerm_bed;
|
|
|
|
temp_dState_bed = current_temperature_bed;
|
|
|
|
|
|
|
|
pid_output = pTerm_bed + iTerm_bed - dTerm_bed;
|
|
|
|
if (pid_output > MAX_BED_POWER) {
|
|
|
|
if (pid_error_bed > 0) temp_iState_bed -= pid_error_bed; // conditional un-integration
|
|
|
|
pid_output = MAX_BED_POWER;
|
|
|
|
}
|
|
|
|
else if (pid_output < 0) {
|
|
|
|
if (pid_error_bed < 0) temp_iState_bed -= pid_error_bed; // conditional un-integration
|
|
|
|
pid_output = 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
pid_output = constrain(target_temperature_bed, 0, MAX_BED_POWER);
|
|
|
|
#endif // PID_OPENLOOP
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PID_BED_DEBUG)
|
2015-03-19 18:07:36 -05:00
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHO(" PID_BED_DEBUG ");
|
|
|
|
SERIAL_ECHO(": Input ");
|
|
|
|
SERIAL_ECHO(current_temperature_bed);
|
|
|
|
SERIAL_ECHO(" Output ");
|
|
|
|
SERIAL_ECHO(pid_output);
|
|
|
|
SERIAL_ECHO(" pTerm ");
|
|
|
|
SERIAL_ECHO(pTerm_bed);
|
|
|
|
SERIAL_ECHO(" iTerm ");
|
|
|
|
SERIAL_ECHO(iTerm_bed);
|
|
|
|
SERIAL_ECHO(" dTerm ");
|
|
|
|
SERIAL_ECHOLN(dTerm_bed);
|
|
|
|
#endif //PID_BED_DEBUG
|
|
|
|
|
2015-03-13 21:49:41 -05:00
|
|
|
return pid_output;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-04-13 19:17:36 -05:00
|
|
|
/**
|
|
|
|
* Manage heating activities for extruder hot-ends and a heated bed
|
|
|
|
* - Acquire updated temperature readings
|
|
|
|
* - Invoke thermal runaway protection
|
|
|
|
* - Manage extruder auto-fan
|
|
|
|
* - Apply filament width to the extrusion rate (may move)
|
|
|
|
* - Update the heated bed PID output value
|
|
|
|
*/
|
2015-02-24 06:46:11 -06:00
|
|
|
void manage_heater() {
|
2011-12-05 22:33:33 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
if (!temp_meas_ready) return;
|
|
|
|
|
2012-12-09 16:00:06 -06:00
|
|
|
updateTemperaturesFromRawValues();
|
2011-11-15 15:50:43 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(HEATER_0_USES_MAX6675)
|
2015-03-25 05:08:24 -05:00
|
|
|
float ct = current_temperature[0];
|
|
|
|
if (ct > min(HEATER_0_MAXTEMP, 1023)) max_temp_error(0);
|
|
|
|
if (ct < max(HEATER_0_MINTEMP, 0.01)) min_temp_error(0);
|
2015-05-09 00:25:51 -05:00
|
|
|
#endif
|
2015-03-25 05:08:24 -05:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS) || DISABLED(PIDTEMPBED) || HAS_AUTO_FAN
|
2015-04-12 20:07:08 -05:00
|
|
|
millis_t ms = millis();
|
2015-03-27 22:29:05 -05:00
|
|
|
#endif
|
2011-12-05 22:33:33 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// Loop through all extruders
|
|
|
|
for (int e = 0; e < EXTRUDERS; e++) {
|
2014-06-30 13:22:37 -05:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS)
|
2015-05-11 00:52:01 -05:00
|
|
|
thermal_runaway_protection(&thermal_runaway_state_machine[e], &thermal_runaway_timer[e], current_temperature[e], target_temperature[e], e, THERMAL_PROTECTION_PERIOD, THERMAL_PROTECTION_HYSTERESIS);
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
|
|
|
|
2015-03-13 21:49:41 -05:00
|
|
|
float pid_output = get_pid_output(e);
|
2011-12-05 22:33:33 -06:00
|
|
|
|
2011-12-12 12:34:37 -06:00
|
|
|
// Check if temperature is within the correct range
|
2015-02-24 06:46:11 -06:00
|
|
|
soft_pwm[e] = current_temperature[e] > minttemp[e] && current_temperature[e] < maxttemp[e] ? (int)pid_output >> 1 : 0;
|
2012-12-06 03:36:07 -06:00
|
|
|
|
2015-05-09 00:25:51 -05:00
|
|
|
// Check if the temperature is failing to increase
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS)
|
2015-05-12 20:22:47 -05:00
|
|
|
|
2015-05-09 00:25:51 -05:00
|
|
|
// Is it time to check this extruder's heater?
|
|
|
|
if (watch_heater_next_ms[e] && ms > watch_heater_next_ms[e]) {
|
|
|
|
// Has it failed to increase enough?
|
2015-05-09 00:36:02 -05:00
|
|
|
if (degHotend(e) < watch_target_temp[e]) {
|
2015-05-09 00:25:51 -05:00
|
|
|
// Stop!
|
2015-05-18 13:26:25 -05:00
|
|
|
_temp_error(e, PSTR(MSG_T_HEATING_FAILED), PSTR(MSG_HEATING_FAILED_LCD));
|
2011-12-09 10:06:56 -06:00
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
else {
|
2015-05-12 20:22:47 -05:00
|
|
|
// Start again if the target is still far off
|
|
|
|
start_watching_heater(e);
|
2015-02-24 06:46:11 -06:00
|
|
|
}
|
|
|
|
}
|
2015-05-12 20:22:47 -05:00
|
|
|
|
2015-05-11 00:52:01 -05:00
|
|
|
#endif // THERMAL_PROTECTION_HOTENDS
|
2015-02-24 06:46:11 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2015-02-24 06:46:11 -06:00
|
|
|
if (fabs(current_temperature[0] - redundant_temperature) > MAX_REDUNDANT_TEMP_SENSOR_DIFF) {
|
2015-03-25 17:26:06 -05:00
|
|
|
_temp_error(0, PSTR(MSG_EXTRUDER_SWITCHED_OFF), PSTR(MSG_ERR_REDUNDANT_TEMP));
|
2013-06-06 17:49:25 -05:00
|
|
|
}
|
2015-05-09 00:25:51 -05:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
|
|
|
|
} // Extruders Loop
|
2012-08-11 01:17:47 -05:00
|
|
|
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_AUTO_FAN
|
2015-04-13 01:06:50 -05:00
|
|
|
if (ms > next_auto_fan_check_ms) { // only need to check fan state very infrequently
|
2015-02-24 06:46:11 -06:00
|
|
|
checkExtruderAutoFans();
|
2015-04-13 01:06:50 -05:00
|
|
|
next_auto_fan_check_ms = ms + 2500;
|
2015-02-24 06:46:11 -06:00
|
|
|
}
|
2013-06-06 17:49:25 -05:00
|
|
|
#endif
|
2015-04-13 19:17:36 -05:00
|
|
|
|
|
|
|
// Control the extruder rate based on the width sensor
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(FILAMENT_SENSOR)
|
2015-04-13 19:17:36 -05:00
|
|
|
if (filament_sensor) {
|
|
|
|
meas_shift_index = delay_index1 - meas_delay_cm;
|
|
|
|
if (meas_shift_index < 0) meas_shift_index += MAX_MEASUREMENT_DELAY + 1; //loop around buffer if needed
|
|
|
|
|
|
|
|
// Get the delayed info and add 100 to reconstitute to a percent of
|
|
|
|
// the nominal filament diameter then square it to get an area
|
|
|
|
meas_shift_index = constrain(meas_shift_index, 0, MAX_MEASUREMENT_DELAY);
|
|
|
|
float vm = pow((measurement_delay[meas_shift_index] + 100.0) / 100.0, 2);
|
|
|
|
if (vm < 0.01) vm = 0.01;
|
|
|
|
volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM] = vm;
|
|
|
|
}
|
|
|
|
#endif //FILAMENT_SENSOR
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if DISABLED(PIDTEMPBED)
|
2015-04-13 01:17:28 -05:00
|
|
|
if (ms < next_bed_check_ms) return;
|
2015-04-13 01:06:50 -05:00
|
|
|
next_bed_check_ms = ms + BED_CHECK_INTERVAL;
|
|
|
|
#endif
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2012-12-09 16:00:06 -06:00
|
|
|
#if TEMP_SENSOR_BED != 0
|
2011-12-22 04:45:52 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_BED)
|
2015-05-11 00:52:01 -05:00
|
|
|
thermal_runaway_protection(&thermal_runaway_bed_state_machine, &thermal_runaway_bed_timer, current_temperature_bed, target_temperature_bed, -1, THERMAL_PROTECTION_BED_PERIOD, THERMAL_PROTECTION_BED_HYSTERESIS);
|
2014-06-30 13:22:37 -05:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2015-03-13 22:19:51 -05:00
|
|
|
float pid_output = get_pid_output_bed();
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
soft_pwm_bed = current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP ? (int)pid_output >> 1 : 0;
|
2012-09-12 21:01:31 -05:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#elif ENABLED(BED_LIMIT_SWITCHING)
|
2015-04-13 19:17:36 -05:00
|
|
|
// Check if temperature is within the correct band
|
2015-02-24 06:46:11 -06:00
|
|
|
if (current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP) {
|
2015-04-13 19:17:36 -05:00
|
|
|
if (current_temperature_bed >= target_temperature_bed + BED_HYSTERESIS)
|
|
|
|
soft_pwm_bed = 0;
|
|
|
|
else if (current_temperature_bed <= target_temperature_bed - BED_HYSTERESIS)
|
|
|
|
soft_pwm_bed = MAX_BED_POWER >> 1;
|
2011-12-22 04:45:52 -06:00
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
else {
|
2012-12-09 16:00:06 -06:00
|
|
|
soft_pwm_bed = 0;
|
2015-02-24 06:46:11 -06:00
|
|
|
WRITE_HEATER_BED(LOW);
|
2011-11-20 06:14:58 -06:00
|
|
|
}
|
2015-04-13 19:17:36 -05:00
|
|
|
#else // BED_LIMIT_SWITCHING
|
|
|
|
// Check if temperature is within the correct range
|
2015-02-24 06:46:11 -06:00
|
|
|
if (current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP) {
|
2015-04-13 19:17:36 -05:00
|
|
|
soft_pwm_bed = current_temperature_bed < target_temperature_bed ? MAX_BED_POWER >> 1 : 0;
|
2011-11-20 06:14:58 -06:00
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
else {
|
2012-12-09 16:00:06 -06:00
|
|
|
soft_pwm_bed = 0;
|
2015-02-24 06:46:11 -06:00
|
|
|
WRITE_HEATER_BED(LOW);
|
2011-12-22 04:45:52 -06:00
|
|
|
}
|
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif //TEMP_SENSOR_BED != 0
|
2011-11-15 15:50:43 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#define PGM_RD_W(x) (short)pgm_read_word(&x)
|
|
|
|
// Derived from RepRap FiveD extruder::getTemperature()
|
|
|
|
// For hot end temperature measurement.
|
2012-12-09 16:00:06 -06:00
|
|
|
static float analog2temp(int raw, uint8_t e) {
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2015-04-13 19:17:36 -05:00
|
|
|
if (e > EXTRUDERS)
|
|
|
|
#else
|
|
|
|
if (e >= EXTRUDERS)
|
|
|
|
#endif
|
|
|
|
{
|
2011-12-05 22:33:33 -06:00
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERROR((int)e);
|
2015-02-25 01:03:08 -06:00
|
|
|
SERIAL_ERRORLNPGM(MSG_INVALID_EXTRUDER_NUM);
|
2015-05-20 14:22:48 -05:00
|
|
|
kill(PSTR(MSG_KILLED));
|
2014-05-15 15:09:50 -05:00
|
|
|
return 0.0;
|
2015-04-13 19:17:36 -05:00
|
|
|
}
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(HEATER_0_USES_MAX6675)
|
2015-04-13 19:17:36 -05:00
|
|
|
if (e == 0) return 0.25 * raw;
|
2012-02-05 06:05:07 -06:00
|
|
|
#endif
|
|
|
|
|
2015-04-13 19:17:36 -05:00
|
|
|
if (heater_ttbl_map[e] != NULL) {
|
2011-11-15 15:50:43 -06:00
|
|
|
float celsius = 0;
|
2012-12-11 07:53:53 -06:00
|
|
|
uint8_t i;
|
2011-12-05 22:33:33 -06:00
|
|
|
short (*tt)[][2] = (short (*)[][2])(heater_ttbl_map[e]);
|
|
|
|
|
2015-04-13 19:17:36 -05:00
|
|
|
for (i = 1; i < heater_ttbllen_map[e]; i++) {
|
|
|
|
if (PGM_RD_W((*tt)[i][0]) > raw) {
|
2011-12-05 22:33:33 -06:00
|
|
|
celsius = PGM_RD_W((*tt)[i-1][1]) +
|
|
|
|
(raw - PGM_RD_W((*tt)[i-1][0])) *
|
|
|
|
(float)(PGM_RD_W((*tt)[i][1]) - PGM_RD_W((*tt)[i-1][1])) /
|
|
|
|
(float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i-1][0]));
|
2011-11-15 15:50:43 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Overflow: Set to last value in the table
|
2011-12-05 22:33:33 -06:00
|
|
|
if (i == heater_ttbllen_map[e]) celsius = PGM_RD_W((*tt)[i-1][1]);
|
2011-11-15 15:50:43 -06:00
|
|
|
|
|
|
|
return celsius;
|
2011-12-05 22:33:33 -06:00
|
|
|
}
|
2012-02-16 04:03:41 -06:00
|
|
|
return ((raw * ((5.0 * 100.0) / 1024.0) / OVERSAMPLENR) * TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET;
|
2011-11-15 15:50:43 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Derived from RepRap FiveD extruder::getTemperature()
|
|
|
|
// For bed temperature measurement.
|
2012-12-09 16:00:06 -06:00
|
|
|
static float analog2tempBed(int raw) {
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(BED_USES_THERMISTOR)
|
2012-03-02 19:15:21 -06:00
|
|
|
float celsius = 0;
|
2011-11-15 15:50:43 -06:00
|
|
|
byte i;
|
|
|
|
|
2015-04-13 19:17:36 -05:00
|
|
|
for (i = 1; i < BEDTEMPTABLE_LEN; i++) {
|
|
|
|
if (PGM_RD_W(BEDTEMPTABLE[i][0]) > raw) {
|
2012-12-11 07:53:53 -06:00
|
|
|
celsius = PGM_RD_W(BEDTEMPTABLE[i-1][1]) +
|
|
|
|
(raw - PGM_RD_W(BEDTEMPTABLE[i-1][0])) *
|
|
|
|
(float)(PGM_RD_W(BEDTEMPTABLE[i][1]) - PGM_RD_W(BEDTEMPTABLE[i-1][1])) /
|
|
|
|
(float)(PGM_RD_W(BEDTEMPTABLE[i][0]) - PGM_RD_W(BEDTEMPTABLE[i-1][0]));
|
2011-11-15 15:50:43 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Overflow: Set to last value in the table
|
2012-12-11 07:53:53 -06:00
|
|
|
if (i == BEDTEMPTABLE_LEN) celsius = PGM_RD_W(BEDTEMPTABLE[i-1][1]);
|
2011-11-15 15:50:43 -06:00
|
|
|
|
|
|
|
return celsius;
|
|
|
|
#elif defined BED_USES_AD595
|
2012-02-16 04:03:41 -06:00
|
|
|
return ((raw * ((5.0 * 100.0) / 1024.0) / OVERSAMPLENR) * TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET;
|
2011-12-04 05:40:18 -06:00
|
|
|
#else
|
2012-03-02 19:15:21 -06:00
|
|
|
return 0;
|
2011-11-15 15:50:43 -06:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-12-09 16:00:06 -06:00
|
|
|
/* Called to get the raw values into the the actual temperatures. The raw values are created in interrupt context,
|
|
|
|
and this function is called from normal context as it is too slow to run in interrupts and will block the stepper routine otherwise */
|
2015-02-26 02:33:30 -06:00
|
|
|
static void updateTemperaturesFromRawValues() {
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(HEATER_0_USES_MAX6675)
|
2015-02-26 02:33:30 -06:00
|
|
|
current_temperature_raw[0] = read_max6675();
|
|
|
|
#endif
|
2015-05-13 04:02:19 -05:00
|
|
|
for (uint8_t e = 0; e < EXTRUDERS; e++) {
|
2015-02-26 02:33:30 -06:00
|
|
|
current_temperature[e] = analog2temp(current_temperature_raw[e], e);
|
|
|
|
}
|
|
|
|
current_temperature_bed = analog2tempBed(current_temperature_bed_raw);
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2015-02-26 02:33:30 -06:00
|
|
|
redundant_temperature = analog2temp(redundant_temperature_raw, 1);
|
|
|
|
#endif
|
|
|
|
#if HAS_FILAMENT_SENSOR
|
|
|
|
filament_width_meas = analog2widthFil();
|
|
|
|
#endif
|
|
|
|
//Reset the watchdog after we know we have a temperature measurement.
|
|
|
|
watchdog_reset();
|
|
|
|
|
|
|
|
CRITICAL_SECTION_START;
|
|
|
|
temp_meas_ready = false;
|
|
|
|
CRITICAL_SECTION_END;
|
2012-12-09 16:00:06 -06:00
|
|
|
}
|
|
|
|
|
2014-08-06 19:30:57 -05:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(FILAMENT_SENSOR)
|
2014-08-06 19:30:57 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// Convert raw Filament Width to millimeters
|
|
|
|
float analog2widthFil() {
|
|
|
|
return current_raw_filwidth / 16383.0 * 5.0;
|
|
|
|
//return current_raw_filwidth;
|
|
|
|
}
|
2014-08-06 19:30:57 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// Convert raw Filament Width to a ratio
|
|
|
|
int widthFil_to_size_ratio() {
|
|
|
|
float temp = filament_width_meas;
|
|
|
|
if (temp < MEASURED_LOWER_LIMIT) temp = filament_width_nominal; //assume sensor cut out
|
|
|
|
else if (temp > MEASURED_UPPER_LIMIT) temp = MEASURED_UPPER_LIMIT;
|
|
|
|
return filament_width_nominal / temp * 100;
|
|
|
|
}
|
2014-08-06 19:30:57 -05:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2015-04-13 19:17:36 -05:00
|
|
|
/**
|
|
|
|
* Initialize the temperature manager
|
|
|
|
* The manager is implemented by periodic calls to manage_heater()
|
|
|
|
*/
|
|
|
|
void tp_init() {
|
2015-02-24 06:46:11 -06:00
|
|
|
#if MB(RUMBA) && ((TEMP_SENSOR_0==-1)||(TEMP_SENSOR_1==-1)||(TEMP_SENSOR_2==-1)||(TEMP_SENSOR_BED==-1))
|
|
|
|
//disable RUMBA JTAG in case the thermocouple extension is plugged on top of JTAG connector
|
2015-03-14 06:28:22 -05:00
|
|
|
MCUCR=BIT(JTD);
|
|
|
|
MCUCR=BIT(JTD);
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
2013-06-06 17:49:25 -05:00
|
|
|
|
2011-12-05 22:33:33 -06:00
|
|
|
// Finish init of mult extruder arrays
|
2015-02-24 06:46:11 -06:00
|
|
|
for (int e = 0; e < EXTRUDERS; e++) {
|
2011-12-05 22:33:33 -06:00
|
|
|
// populate with the first value
|
|
|
|
maxttemp[e] = maxttemp[0];
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_iState_min[e] = 0.0;
|
|
|
|
temp_iState_max[e] = PID_INTEGRAL_DRIVE_MAX / PID_PARAM(Ki,e);
|
2015-08-30 21:04:30 -05:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
|
|
|
last_position[e] = 0;
|
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif //PIDTEMP
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_iState_min_bed = 0.0;
|
2015-05-28 10:30:56 -05:00
|
|
|
temp_iState_max_bed = PID_BED_INTEGRAL_DRIVE_MAX / bedKi;
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif //PIDTEMPBED
|
2011-12-05 22:33:33 -06:00
|
|
|
}
|
|
|
|
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_0
|
2011-11-15 15:50:43 -06:00
|
|
|
SET_OUTPUT(HEATER_0_PIN);
|
2015-01-23 16:13:06 -06:00
|
|
|
#endif
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_1
|
2011-11-15 15:50:43 -06:00
|
|
|
SET_OUTPUT(HEATER_1_PIN);
|
2015-01-23 12:37:39 -06:00
|
|
|
#endif
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_2
|
2011-11-15 15:50:43 -06:00
|
|
|
SET_OUTPUT(HEATER_2_PIN);
|
2015-01-23 16:13:06 -06:00
|
|
|
#endif
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_3
|
2015-01-23 16:13:06 -06:00
|
|
|
SET_OUTPUT(HEATER_3_PIN);
|
|
|
|
#endif
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_BED
|
2011-12-05 22:33:33 -06:00
|
|
|
SET_OUTPUT(HEATER_BED_PIN);
|
|
|
|
#endif
|
2015-02-26 03:14:59 -06:00
|
|
|
#if HAS_FAN
|
2011-12-05 22:33:33 -06:00
|
|
|
SET_OUTPUT(FAN_PIN);
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(FAST_PWM_FAN)
|
2015-02-24 06:46:11 -06:00
|
|
|
setPwmFrequency(FAN_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
|
2012-05-02 12:26:14 -05:00
|
|
|
#endif
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
2015-02-24 06:46:11 -06:00
|
|
|
soft_pwm_fan = fanSpeedSoftPwm / 2;
|
2013-06-09 05:52:49 -05:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
2011-11-15 15:50:43 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(HEATER_0_USES_MAX6675)
|
2015-01-23 12:37:39 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if DISABLED(SDSUPPORT)
|
2015-03-03 02:48:20 -06:00
|
|
|
OUT_WRITE(SCK_PIN, LOW);
|
|
|
|
OUT_WRITE(MOSI_PIN, HIGH);
|
|
|
|
OUT_WRITE(MISO_PIN, HIGH);
|
2015-01-23 12:37:39 -06:00
|
|
|
#else
|
|
|
|
pinMode(SS_PIN, OUTPUT);
|
|
|
|
digitalWrite(SS_PIN, HIGH);
|
2012-02-05 06:05:07 -06:00
|
|
|
#endif
|
|
|
|
|
2015-03-03 02:48:20 -06:00
|
|
|
OUT_WRITE(MAX6675_SS,HIGH);
|
2015-01-23 12:37:39 -06:00
|
|
|
|
|
|
|
#endif //HEATER_0_USES_MAX6675
|
2012-02-05 06:05:07 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
#ifdef DIDR2
|
2015-03-14 06:28:22 -05:00
|
|
|
#define ANALOG_SELECT(pin) do{ if (pin < 8) DIDR0 |= BIT(pin); else DIDR2 |= BIT(pin - 8); }while(0)
|
2015-02-24 06:46:11 -06:00
|
|
|
#else
|
2015-03-14 06:28:22 -05:00
|
|
|
#define ANALOG_SELECT(pin) do{ DIDR0 |= BIT(pin); }while(0)
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
|
|
|
|
2011-11-15 15:50:43 -06:00
|
|
|
// Set analog inputs
|
2015-03-14 06:28:22 -05:00
|
|
|
ADCSRA = BIT(ADEN) | BIT(ADSC) | BIT(ADIF) | 0x07;
|
2011-11-20 06:14:58 -06:00
|
|
|
DIDR0 = 0;
|
|
|
|
#ifdef DIDR2
|
|
|
|
DIDR2 = 0;
|
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
#if HAS_TEMP_0
|
|
|
|
ANALOG_SELECT(TEMP_0_PIN);
|
2011-11-20 06:14:58 -06:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
#if HAS_TEMP_1
|
|
|
|
ANALOG_SELECT(TEMP_1_PIN);
|
2011-11-20 06:14:58 -06:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
#if HAS_TEMP_2
|
|
|
|
ANALOG_SELECT(TEMP_2_PIN);
|
2015-01-23 16:13:06 -06:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
#if HAS_TEMP_3
|
|
|
|
ANALOG_SELECT(TEMP_3_PIN);
|
2011-11-20 06:14:58 -06:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
#if HAS_TEMP_BED
|
|
|
|
ANALOG_SELECT(TEMP_BED_PIN);
|
2011-12-05 22:33:33 -06:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
#if HAS_FILAMENT_SENSOR
|
|
|
|
ANALOG_SELECT(FILWIDTH_PIN);
|
2014-08-06 19:30:57 -05:00
|
|
|
#endif
|
2015-06-09 19:01:47 -05:00
|
|
|
|
2015-06-09 18:54:28 -05:00
|
|
|
#if HAS_AUTO_FAN_0
|
|
|
|
pinMode(EXTRUDER_0_AUTO_FAN_PIN, OUTPUT);
|
|
|
|
#endif
|
|
|
|
#if HAS_AUTO_FAN_1 && (EXTRUDER_1_AUTO_FAN_PIN != EXTRUDER_0_AUTO_FAN_PIN)
|
|
|
|
pinMode(EXTRUDER_1_AUTO_FAN_PIN, OUTPUT);
|
|
|
|
#endif
|
|
|
|
#if HAS_AUTO_FAN_2 && (EXTRUDER_2_AUTO_FAN_PIN != EXTRUDER_0_AUTO_FAN_PIN) && (EXTRUDER_2_AUTO_FAN_PIN != EXTRUDER_1_AUTO_FAN_PIN)
|
|
|
|
pinMode(EXTRUDER_2_AUTO_FAN_PIN, OUTPUT);
|
|
|
|
#endif
|
|
|
|
#if HAS_AUTO_FAN_3 && (EXTRUDER_3_AUTO_FAN_PIN != EXTRUDER_0_AUTO_FAN_PIN) && (EXTRUDER_3_AUTO_FAN_PIN != EXTRUDER_1_AUTO_FAN_PIN) && (EXTRUDER_3_AUTO_FAN_PIN != EXTRUDER_2_AUTO_FAN_PIN)
|
|
|
|
pinMode(EXTRUDER_3_AUTO_FAN_PIN, OUTPUT);
|
|
|
|
#endif
|
|
|
|
|
2011-11-15 15:50:43 -06:00
|
|
|
// Use timer0 for temperature measurement
|
|
|
|
// Interleave temperature interrupt with millies interrupt
|
|
|
|
OCR0B = 128;
|
2015-03-14 06:28:22 -05:00
|
|
|
TIMSK0 |= BIT(OCIE0B);
|
2011-11-19 05:19:53 -06:00
|
|
|
|
|
|
|
// Wait for temperature measurement to settle
|
2011-12-05 22:33:33 -06:00
|
|
|
delay(250);
|
2011-11-19 05:19:53 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
#define TEMP_MIN_ROUTINE(NR) \
|
|
|
|
minttemp[NR] = HEATER_ ## NR ## _MINTEMP; \
|
|
|
|
while(analog2temp(minttemp_raw[NR], NR) < HEATER_ ## NR ## _MINTEMP) { \
|
|
|
|
if (HEATER_ ## NR ## _RAW_LO_TEMP < HEATER_ ## NR ## _RAW_HI_TEMP) \
|
|
|
|
minttemp_raw[NR] += OVERSAMPLENR; \
|
|
|
|
else \
|
|
|
|
minttemp_raw[NR] -= OVERSAMPLENR; \
|
|
|
|
}
|
|
|
|
#define TEMP_MAX_ROUTINE(NR) \
|
|
|
|
maxttemp[NR] = HEATER_ ## NR ## _MAXTEMP; \
|
|
|
|
while(analog2temp(maxttemp_raw[NR], NR) > HEATER_ ## NR ## _MAXTEMP) { \
|
|
|
|
if (HEATER_ ## NR ## _RAW_LO_TEMP < HEATER_ ## NR ## _RAW_HI_TEMP) \
|
|
|
|
maxttemp_raw[NR] -= OVERSAMPLENR; \
|
|
|
|
else \
|
|
|
|
maxttemp_raw[NR] += OVERSAMPLENR; \
|
|
|
|
}
|
2015-01-23 16:13:06 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
#ifdef HEATER_0_MINTEMP
|
|
|
|
TEMP_MIN_ROUTINE(0);
|
|
|
|
#endif
|
|
|
|
#ifdef HEATER_0_MAXTEMP
|
|
|
|
TEMP_MAX_ROUTINE(0);
|
|
|
|
#endif
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
#ifdef HEATER_1_MINTEMP
|
|
|
|
TEMP_MIN_ROUTINE(1);
|
|
|
|
#endif
|
|
|
|
#ifdef HEATER_1_MAXTEMP
|
|
|
|
TEMP_MAX_ROUTINE(1);
|
|
|
|
#endif
|
|
|
|
#if EXTRUDERS > 2
|
|
|
|
#ifdef HEATER_2_MINTEMP
|
|
|
|
TEMP_MIN_ROUTINE(2);
|
|
|
|
#endif
|
|
|
|
#ifdef HEATER_2_MAXTEMP
|
|
|
|
TEMP_MAX_ROUTINE(2);
|
|
|
|
#endif
|
|
|
|
#if EXTRUDERS > 3
|
|
|
|
#ifdef HEATER_3_MINTEMP
|
|
|
|
TEMP_MIN_ROUTINE(3);
|
|
|
|
#endif
|
|
|
|
#ifdef HEATER_3_MAXTEMP
|
|
|
|
TEMP_MAX_ROUTINE(3);
|
|
|
|
#endif
|
|
|
|
#endif // EXTRUDERS > 3
|
|
|
|
#endif // EXTRUDERS > 2
|
|
|
|
#endif // EXTRUDERS > 1
|
|
|
|
|
|
|
|
#ifdef BED_MINTEMP
|
|
|
|
while(analog2tempBed(bed_minttemp_raw) < BED_MINTEMP) {
|
|
|
|
#if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP
|
|
|
|
bed_minttemp_raw += OVERSAMPLENR;
|
|
|
|
#else
|
|
|
|
bed_minttemp_raw -= OVERSAMPLENR;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif //BED_MINTEMP
|
|
|
|
#ifdef BED_MAXTEMP
|
|
|
|
while(analog2tempBed(bed_maxttemp_raw) > BED_MAXTEMP) {
|
|
|
|
#if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP
|
|
|
|
bed_maxttemp_raw -= OVERSAMPLENR;
|
|
|
|
#else
|
|
|
|
bed_maxttemp_raw += OVERSAMPLENR;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif //BED_MAXTEMP
|
2011-11-15 15:50:43 -06:00
|
|
|
}
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS)
|
2015-05-09 00:36:02 -05: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)
|
|
|
|
*/
|
2015-05-10 22:26:45 -05:00
|
|
|
void start_watching_heater(int e) {
|
2015-05-12 20:30:38 -05:00
|
|
|
if (degHotend(e) < degTargetHotend(e) - (WATCH_TEMP_INCREASE + TEMP_HYSTERESIS + 1)) {
|
2015-05-10 22:26:45 -05:00
|
|
|
watch_target_temp[e] = degHotend(e) + WATCH_TEMP_INCREASE;
|
2015-07-27 18:17:00 -05:00
|
|
|
watch_heater_next_ms[e] = millis() + WATCH_TEMP_PERIOD * 1000UL;
|
2015-05-10 22:26:45 -05:00
|
|
|
}
|
|
|
|
else
|
|
|
|
watch_heater_next_ms[e] = 0;
|
2015-05-09 00:36:02 -05:00
|
|
|
}
|
|
|
|
#endif
|
2011-11-15 15:50:43 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(THERMAL_PROTECTION_HOTENDS) || ENABLED(THERMAL_PROTECTION_BED)
|
2015-04-02 07:10:14 -05:00
|
|
|
|
2015-04-12 20:07:08 -05:00
|
|
|
void thermal_runaway_protection(TRState *state, millis_t *timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc) {
|
2015-04-03 21:34:55 -05:00
|
|
|
|
2015-04-04 07:45:36 -05:00
|
|
|
static float tr_target_temperature[EXTRUDERS+1] = { 0.0 };
|
2015-04-03 21:34:55 -05:00
|
|
|
|
2015-04-02 07:10:14 -05:00
|
|
|
/*
|
|
|
|
SERIAL_ECHO_START;
|
2015-04-03 21:42:40 -05:00
|
|
|
SERIAL_ECHOPGM("Thermal Thermal Runaway Running. Heater ID: ");
|
|
|
|
if (heater_id < 0) SERIAL_ECHOPGM("bed"); else SERIAL_ECHOPGM(heater_id);
|
|
|
|
SERIAL_ECHOPGM(" ; State:");
|
|
|
|
SERIAL_ECHOPGM(*state);
|
|
|
|
SERIAL_ECHOPGM(" ; Timer:");
|
|
|
|
SERIAL_ECHOPGM(*timer);
|
|
|
|
SERIAL_ECHOPGM(" ; Temperature:");
|
|
|
|
SERIAL_ECHOPGM(temperature);
|
|
|
|
SERIAL_ECHOPGM(" ; Target Temp:");
|
|
|
|
SERIAL_ECHOPGM(target_temperature);
|
|
|
|
SERIAL_EOL;
|
2015-04-02 07:10:14 -05:00
|
|
|
*/
|
2015-04-04 07:45:36 -05:00
|
|
|
|
2015-04-04 08:18:08 -05:00
|
|
|
int heater_index = heater_id >= 0 ? heater_id : EXTRUDERS;
|
|
|
|
|
2015-04-04 07:45:36 -05:00
|
|
|
// If the target temperature changes, restart
|
|
|
|
if (tr_target_temperature[heater_index] != target_temperature)
|
|
|
|
*state = TRReset;
|
2015-04-02 07:10:14 -05:00
|
|
|
|
|
|
|
switch (*state) {
|
2015-04-04 07:45:36 -05:00
|
|
|
case TRReset:
|
|
|
|
*timer = 0;
|
|
|
|
*state = TRInactive;
|
2015-04-02 08:11:03 -05:00
|
|
|
// Inactive state waits for a target temperature to be set
|
2015-04-02 07:10:14 -05:00
|
|
|
case TRInactive:
|
2015-04-03 21:34:55 -05:00
|
|
|
if (target_temperature > 0) {
|
2015-04-03 21:42:40 -05:00
|
|
|
tr_target_temperature[heater_index] = target_temperature;
|
2015-04-04 07:45:36 -05:00
|
|
|
*state = TRFirstHeating;
|
2015-04-03 21:34:55 -05:00
|
|
|
}
|
2015-04-02 07:10:14 -05:00
|
|
|
break;
|
|
|
|
// When first heating, wait for the temperature to be reached then go to Stable state
|
|
|
|
case TRFirstHeating:
|
2015-04-03 21:42:40 -05:00
|
|
|
if (temperature >= tr_target_temperature[heater_index]) *state = TRStable;
|
2015-04-02 07:10:14 -05:00
|
|
|
break;
|
|
|
|
// While the temperature is stable watch for a bad temperature
|
|
|
|
case TRStable:
|
2015-04-03 21:34:55 -05:00
|
|
|
// If the temperature is over the target (-hysteresis) restart the timer
|
2015-04-04 07:45:36 -05:00
|
|
|
if (temperature >= tr_target_temperature[heater_index] - hysteresis_degc)
|
2015-04-04 07:25:53 -05:00
|
|
|
*timer = millis();
|
2015-04-04 07:45:36 -05:00
|
|
|
// If the timer goes too long without a reset, trigger shutdown
|
|
|
|
else if (millis() > *timer + period_seconds * 1000UL)
|
|
|
|
*state = TRRunaway;
|
|
|
|
break;
|
|
|
|
case TRRunaway:
|
2015-05-18 13:26:25 -05:00
|
|
|
_temp_error(heater_id, PSTR(MSG_T_THERMAL_RUNAWAY), PSTR(MSG_THERMAL_RUNAWAY));
|
2015-04-02 07:10:14 -05:00
|
|
|
}
|
2014-06-30 13:22:37 -05:00
|
|
|
}
|
2011-11-15 15:50:43 -06:00
|
|
|
|
2015-05-11 00:52:01 -05:00
|
|
|
#endif // THERMAL_PROTECTION_HOTENDS || THERMAL_PROTECTION_BED
|
2015-02-24 06:46:11 -06:00
|
|
|
|
2015-04-13 19:17:36 -05:00
|
|
|
void disable_all_heaters() {
|
2015-02-24 06:46:11 -06:00
|
|
|
for (int i=0; i<EXTRUDERS; i++) setTargetHotend(0, i);
|
2011-12-22 04:45:52 -06:00
|
|
|
setTargetBed(0);
|
2015-02-24 06:46:11 -06:00
|
|
|
|
2015-03-23 17:18:22 -05:00
|
|
|
#define DISABLE_HEATER(NR) { \
|
|
|
|
target_temperature[NR] = 0; \
|
|
|
|
soft_pwm[NR] = 0; \
|
|
|
|
WRITE_HEATER_ ## NR (LOW); \
|
|
|
|
}
|
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
#if HAS_TEMP_0
|
|
|
|
target_temperature[0] = 0;
|
|
|
|
soft_pwm[0] = 0;
|
2015-03-23 17:18:22 -05:00
|
|
|
WRITE_HEATER_0P(LOW); // Should HEATERS_PARALLEL apply here? Then change to DISABLE_HEATER(0)
|
2011-11-15 15:50:43 -06:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
|
|
|
|
#if EXTRUDERS > 1 && HAS_TEMP_1
|
2015-03-23 17:18:22 -05:00
|
|
|
DISABLE_HEATER(1);
|
2015-01-23 16:13:06 -06:00
|
|
|
#endif
|
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
#if EXTRUDERS > 2 && HAS_TEMP_2
|
2015-03-23 17:18:22 -05:00
|
|
|
DISABLE_HEATER(2);
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
2011-12-05 22:33:33 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
#if EXTRUDERS > 3 && HAS_TEMP_3
|
2015-03-23 17:18:22 -05:00
|
|
|
DISABLE_HEATER(3);
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
2015-01-23 16:13:06 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
#if HAS_TEMP_BED
|
|
|
|
target_temperature_bed = 0;
|
|
|
|
soft_pwm_bed = 0;
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_BED
|
2015-02-24 06:46:11 -06:00
|
|
|
WRITE_HEATER_BED(LOW);
|
2011-12-05 22:33:33 -06:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
2011-11-15 15:50:43 -06:00
|
|
|
}
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(HEATER_0_USES_MAX6675)
|
2015-03-29 18:58:46 -05:00
|
|
|
#define MAX6675_HEAT_INTERVAL 250u
|
2015-04-13 01:06:50 -05:00
|
|
|
static millis_t next_max6675_ms = 0;
|
2015-02-24 06:46:11 -06:00
|
|
|
int max6675_temp = 2000;
|
2012-02-05 06:05:07 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
static int read_max6675() {
|
|
|
|
|
2015-04-12 20:07:08 -05:00
|
|
|
millis_t ms = millis();
|
2015-04-13 01:06:50 -05:00
|
|
|
|
|
|
|
if (ms < next_max6675_ms)
|
2015-02-24 06:46:11 -06:00
|
|
|
return max6675_temp;
|
2012-02-05 06:05:07 -06:00
|
|
|
|
2015-04-13 01:06:50 -05:00
|
|
|
next_max6675_ms = ms + MAX6675_HEAT_INTERVAL;
|
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
max6675_temp = 0;
|
2012-02-05 06:05:07 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
#ifdef PRR
|
2015-03-14 06:28:22 -05:00
|
|
|
PRR &= ~BIT(PRSPI);
|
2015-02-24 06:46:11 -06:00
|
|
|
#elif defined(PRR0)
|
2015-03-14 06:28:22 -05:00
|
|
|
PRR0 &= ~BIT(PRSPI);
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
2012-02-05 06:05:07 -06:00
|
|
|
|
2015-03-14 06:28:22 -05:00
|
|
|
SPCR = BIT(MSTR) | BIT(SPE) | BIT(SPR0);
|
2015-01-23 12:37:39 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// enable TT_MAX6675
|
|
|
|
WRITE(MAX6675_SS, 0);
|
|
|
|
|
|
|
|
// ensure 100ns delay - a bit extra is fine
|
|
|
|
asm("nop");//50ns on 20Mhz, 62.5ns on 16Mhz
|
|
|
|
asm("nop");//50ns on 20Mhz, 62.5ns on 16Mhz
|
2012-02-05 06:05:07 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// read MSB
|
|
|
|
SPDR = 0;
|
2015-03-14 06:28:22 -05:00
|
|
|
for (;(SPSR & BIT(SPIF)) == 0;);
|
2015-02-24 06:46:11 -06:00
|
|
|
max6675_temp = SPDR;
|
|
|
|
max6675_temp <<= 8;
|
2012-02-05 06:05:07 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// read LSB
|
|
|
|
SPDR = 0;
|
2015-03-14 06:28:22 -05:00
|
|
|
for (;(SPSR & BIT(SPIF)) == 0;);
|
2015-02-24 06:46:11 -06:00
|
|
|
max6675_temp |= SPDR;
|
|
|
|
|
|
|
|
// disable TT_MAX6675
|
|
|
|
WRITE(MAX6675_SS, 1);
|
|
|
|
|
|
|
|
if (max6675_temp & 4) {
|
|
|
|
// thermocouple open
|
|
|
|
max6675_temp = 4000;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
max6675_temp = max6675_temp >> 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
return max6675_temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif //HEATER_0_USES_MAX6675
|
|
|
|
|
2015-02-26 02:33:30 -06:00
|
|
|
/**
|
|
|
|
* Stages in the ISR loop
|
|
|
|
*/
|
2015-02-24 06:46:11 -06:00
|
|
|
enum TempState {
|
|
|
|
PrepareTemp_0,
|
|
|
|
MeasureTemp_0,
|
|
|
|
PrepareTemp_BED,
|
|
|
|
MeasureTemp_BED,
|
|
|
|
PrepareTemp_1,
|
|
|
|
MeasureTemp_1,
|
|
|
|
PrepareTemp_2,
|
|
|
|
MeasureTemp_2,
|
|
|
|
PrepareTemp_3,
|
|
|
|
MeasureTemp_3,
|
|
|
|
Prepare_FILWIDTH,
|
|
|
|
Measure_FILWIDTH,
|
|
|
|
StartupDelay // Startup, delay initial temp reading a tiny bit so the hardware can settle
|
|
|
|
};
|
|
|
|
|
2015-03-26 18:22:21 -05:00
|
|
|
static unsigned long raw_temp_value[4] = { 0 };
|
2015-03-25 15:37:15 -05:00
|
|
|
static unsigned long raw_temp_bed_value = 0;
|
2015-03-25 05:08:24 -05:00
|
|
|
|
2015-03-25 15:37:15 -05:00
|
|
|
static void set_current_temp_raw() {
|
2015-07-31 00:29:30 -05:00
|
|
|
#if HAS_TEMP_0 && DISABLED(HEATER_0_USES_MAX6675)
|
2015-03-25 05:08:24 -05:00
|
|
|
current_temperature_raw[0] = raw_temp_value[0];
|
|
|
|
#endif
|
2015-03-26 18:22:21 -05:00
|
|
|
#if HAS_TEMP_1
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
|
2015-03-27 18:37:22 -05:00
|
|
|
redundant_temperature_raw = raw_temp_value[1];
|
|
|
|
#else
|
|
|
|
current_temperature_raw[1] = raw_temp_value[1];
|
2015-03-26 18:22:21 -05:00
|
|
|
#endif
|
|
|
|
#if HAS_TEMP_2
|
2015-03-25 05:08:24 -05:00
|
|
|
current_temperature_raw[2] = raw_temp_value[2];
|
2015-03-26 18:22:21 -05:00
|
|
|
#if HAS_TEMP_3
|
2015-03-25 05:08:24 -05:00
|
|
|
current_temperature_raw[3] = raw_temp_value[3];
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
current_temperature_bed_raw = raw_temp_bed_value;
|
2015-03-26 18:22:21 -05:00
|
|
|
temp_meas_ready = true;
|
2015-03-25 05:08:24 -05:00
|
|
|
}
|
|
|
|
|
2015-04-13 19:17:36 -05:00
|
|
|
/**
|
|
|
|
* Timer 0 is shared with millies
|
|
|
|
* - Manage PWM to all the heaters and fan
|
|
|
|
* - Update the raw temperature values
|
|
|
|
* - Check new temperature values for MIN/MAX errors
|
|
|
|
* - Step the babysteps value for each axis towards 0
|
|
|
|
*/
|
2015-02-24 06:46:11 -06:00
|
|
|
ISR(TIMER0_COMPB_vect) {
|
2015-04-13 19:17:36 -05:00
|
|
|
|
2011-11-15 15:50:43 -06:00
|
|
|
static unsigned char temp_count = 0;
|
2015-02-24 06:46:11 -06:00
|
|
|
static TempState temp_state = StartupDelay;
|
2015-03-14 06:28:22 -05:00
|
|
|
static unsigned char pwm_count = BIT(SOFT_PWM_SCALE);
|
2015-01-23 16:13:06 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// Static members for each heater
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(SLOW_PWM_HEATERS)
|
2015-02-24 06:46:11 -06:00
|
|
|
static unsigned char slow_pwm_count = 0;
|
|
|
|
#define ISR_STATICS(n) \
|
|
|
|
static unsigned char soft_pwm_ ## n; \
|
|
|
|
static unsigned char state_heater_ ## n = 0; \
|
|
|
|
static unsigned char state_timer_heater_ ## n = 0
|
|
|
|
#else
|
|
|
|
#define ISR_STATICS(n) static unsigned char soft_pwm_ ## n
|
2015-06-12 06:12:55 -05:00
|
|
|
#endif
|
2015-01-23 16:13:06 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// Statics per heater
|
|
|
|
ISR_STATICS(0);
|
2015-07-31 00:29:30 -05:00
|
|
|
#if (EXTRUDERS > 1) || ENABLED(HEATERS_PARALLEL)
|
2015-02-24 06:46:11 -06:00
|
|
|
ISR_STATICS(1);
|
|
|
|
#if EXTRUDERS > 2
|
|
|
|
ISR_STATICS(2);
|
|
|
|
#if EXTRUDERS > 3
|
|
|
|
ISR_STATICS(3);
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_BED
|
2015-02-24 06:46:11 -06:00
|
|
|
ISR_STATICS(BED);
|
|
|
|
#endif
|
2015-01-23 16:13:06 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
#if HAS_FILAMENT_SENSOR
|
|
|
|
static unsigned long raw_filwidth_value = 0;
|
|
|
|
#endif
|
2015-01-06 11:32:17 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if DISABLED(SLOW_PWM_HEATERS)
|
2015-02-24 06:46:11 -06:00
|
|
|
/**
|
|
|
|
* standard PWM modulation
|
|
|
|
*/
|
|
|
|
if (pwm_count == 0) {
|
|
|
|
soft_pwm_0 = soft_pwm[0];
|
|
|
|
if (soft_pwm_0 > 0) {
|
|
|
|
WRITE_HEATER_0(1);
|
2015-01-06 11:32:17 -06:00
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
else WRITE_HEATER_0P(0); // If HEATERS_PARALLEL should apply, change to WRITE_HEATER_0
|
|
|
|
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
soft_pwm_1 = soft_pwm[1];
|
|
|
|
WRITE_HEATER_1(soft_pwm_1 > 0 ? 1 : 0);
|
|
|
|
#if EXTRUDERS > 2
|
|
|
|
soft_pwm_2 = soft_pwm[2];
|
|
|
|
WRITE_HEATER_2(soft_pwm_2 > 0 ? 1 : 0);
|
|
|
|
#if EXTRUDERS > 3
|
|
|
|
soft_pwm_3 = soft_pwm[3];
|
|
|
|
WRITE_HEATER_3(soft_pwm_3 > 0 ? 1 : 0);
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
2015-01-23 16:13:06 -06:00
|
|
|
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_BED
|
2015-02-24 06:46:11 -06:00
|
|
|
soft_pwm_BED = soft_pwm_bed;
|
|
|
|
WRITE_HEATER_BED(soft_pwm_BED > 0 ? 1 : 0);
|
|
|
|
#endif
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
2015-02-24 06:46:11 -06:00
|
|
|
soft_pwm_fan = fanSpeedSoftPwm / 2;
|
2015-02-26 03:14:59 -06:00
|
|
|
WRITE_FAN(soft_pwm_fan > 0 ? 1 : 0);
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
2015-01-23 16:13:06 -06:00
|
|
|
}
|
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
if (soft_pwm_0 < pwm_count) { WRITE_HEATER_0(0); }
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
if (soft_pwm_1 < pwm_count) WRITE_HEATER_1(0);
|
|
|
|
#if EXTRUDERS > 2
|
|
|
|
if (soft_pwm_2 < pwm_count) WRITE_HEATER_2(0);
|
|
|
|
#if EXTRUDERS > 3
|
|
|
|
if (soft_pwm_3 < pwm_count) WRITE_HEATER_3(0);
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_BED
|
2015-02-24 06:46:11 -06:00
|
|
|
if (soft_pwm_BED < pwm_count) WRITE_HEATER_BED(0);
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
2015-02-26 03:14:59 -06:00
|
|
|
if (soft_pwm_fan < pwm_count) WRITE_FAN(0);
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
2015-01-06 11:32:17 -06:00
|
|
|
|
2015-03-14 06:28:22 -05:00
|
|
|
pwm_count += BIT(SOFT_PWM_SCALE);
|
2015-02-24 06:46:11 -06:00
|
|
|
pwm_count &= 0x7f;
|
2015-01-06 11:32:17 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
#else // SLOW_PWM_HEATERS
|
|
|
|
/*
|
|
|
|
* SLOW PWM HEATERS
|
|
|
|
*
|
|
|
|
* for heaters drived by relay
|
|
|
|
*/
|
|
|
|
#ifndef MIN_STATE_TIME
|
|
|
|
#define MIN_STATE_TIME 16 // MIN_STATE_TIME * 65.5 = time in milliseconds
|
|
|
|
#endif
|
2015-01-23 16:13:06 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// Macros for Slow PWM timer logic - HEATERS_PARALLEL applies
|
|
|
|
#define _SLOW_PWM_ROUTINE(NR, src) \
|
|
|
|
soft_pwm_ ## NR = src; \
|
|
|
|
if (soft_pwm_ ## NR > 0) { \
|
|
|
|
if (state_timer_heater_ ## NR == 0) { \
|
|
|
|
if (state_heater_ ## NR == 0) state_timer_heater_ ## NR = MIN_STATE_TIME; \
|
|
|
|
state_heater_ ## NR = 1; \
|
|
|
|
WRITE_HEATER_ ## NR(1); \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
else { \
|
|
|
|
if (state_timer_heater_ ## NR == 0) { \
|
|
|
|
if (state_heater_ ## NR == 1) state_timer_heater_ ## NR = MIN_STATE_TIME; \
|
|
|
|
state_heater_ ## NR = 0; \
|
|
|
|
WRITE_HEATER_ ## NR(0); \
|
|
|
|
} \
|
2015-01-23 16:13:06 -06:00
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
#define SLOW_PWM_ROUTINE(n) _SLOW_PWM_ROUTINE(n, soft_pwm[n])
|
|
|
|
|
|
|
|
#define PWM_OFF_ROUTINE(NR) \
|
|
|
|
if (soft_pwm_ ## NR < slow_pwm_count) { \
|
|
|
|
if (state_timer_heater_ ## NR == 0) { \
|
|
|
|
if (state_heater_ ## NR == 1) state_timer_heater_ ## NR = MIN_STATE_TIME; \
|
|
|
|
state_heater_ ## NR = 0; \
|
|
|
|
WRITE_HEATER_ ## NR (0); \
|
|
|
|
} \
|
2015-01-06 11:32:17 -06:00
|
|
|
}
|
2015-01-23 16:13:06 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
if (slow_pwm_count == 0) {
|
|
|
|
|
|
|
|
SLOW_PWM_ROUTINE(0); // EXTRUDER 0
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
SLOW_PWM_ROUTINE(1); // EXTRUDER 1
|
|
|
|
#if EXTRUDERS > 2
|
|
|
|
SLOW_PWM_ROUTINE(2); // EXTRUDER 2
|
|
|
|
#if EXTRUDERS > 3
|
|
|
|
SLOW_PWM_ROUTINE(3); // EXTRUDER 3
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_BED
|
2015-02-24 06:46:11 -06:00
|
|
|
_SLOW_PWM_ROUTINE(BED, soft_pwm_bed); // BED
|
|
|
|
#endif
|
|
|
|
|
|
|
|
} // slow_pwm_count == 0
|
|
|
|
|
|
|
|
PWM_OFF_ROUTINE(0); // EXTRUDER 0
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
PWM_OFF_ROUTINE(1); // EXTRUDER 1
|
|
|
|
#if EXTRUDERS > 2
|
|
|
|
PWM_OFF_ROUTINE(2); // EXTRUDER 2
|
|
|
|
#if EXTRUDERS > 3
|
|
|
|
PWM_OFF_ROUTINE(3); // EXTRUDER 3
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_BED
|
2015-02-24 06:46:11 -06:00
|
|
|
PWM_OFF_ROUTINE(BED); // BED
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(FAN_SOFT_PWM)
|
2015-02-24 06:46:11 -06:00
|
|
|
if (pwm_count == 0) {
|
|
|
|
soft_pwm_fan = fanSpeedSoftPwm / 2;
|
2015-02-26 03:14:59 -06:00
|
|
|
WRITE_FAN(soft_pwm_fan > 0 ? 1 : 0);
|
2015-02-24 06:46:11 -06:00
|
|
|
}
|
2015-02-26 03:14:59 -06:00
|
|
|
if (soft_pwm_fan < pwm_count) WRITE_FAN(0);
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif //FAN_SOFT_PWM
|
|
|
|
|
2015-03-14 06:28:22 -05:00
|
|
|
pwm_count += BIT(SOFT_PWM_SCALE);
|
2015-02-24 06:46:11 -06:00
|
|
|
pwm_count &= 0x7f;
|
|
|
|
|
|
|
|
// increment slow_pwm_count only every 64 pwm_count circa 65.5ms
|
|
|
|
if ((pwm_count % 64) == 0) {
|
|
|
|
slow_pwm_count++;
|
|
|
|
slow_pwm_count &= 0x7f;
|
2015-01-06 11:32:17 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// EXTRUDER 0
|
|
|
|
if (state_timer_heater_0 > 0) state_timer_heater_0--;
|
|
|
|
#if EXTRUDERS > 1 // EXTRUDER 1
|
|
|
|
if (state_timer_heater_1 > 0) state_timer_heater_1--;
|
|
|
|
#if EXTRUDERS > 2 // EXTRUDER 2
|
|
|
|
if (state_timer_heater_2 > 0) state_timer_heater_2--;
|
|
|
|
#if EXTRUDERS > 3 // EXTRUDER 3
|
|
|
|
if (state_timer_heater_3 > 0) state_timer_heater_3--;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
2015-02-26 02:33:30 -06:00
|
|
|
#if HAS_HEATER_BED
|
2015-02-24 06:46:11 -06:00
|
|
|
if (state_timer_heater_BED > 0) state_timer_heater_BED--;
|
|
|
|
#endif
|
|
|
|
} // (pwm_count % 64) == 0
|
2015-01-06 11:32:17 -06:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif // SLOW_PWM_HEATERS
|
|
|
|
|
2015-03-14 06:28:22 -05:00
|
|
|
#define SET_ADMUX_ADCSRA(pin) ADMUX = BIT(REFS0) | (pin & 0x07); ADCSRA |= BIT(ADSC)
|
2015-02-24 06:46:11 -06:00
|
|
|
#ifdef MUX5
|
2015-03-14 06:28:22 -05:00
|
|
|
#define START_ADC(pin) if (pin > 7) ADCSRB = BIT(MUX5); else ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
|
2015-02-24 06:46:11 -06:00
|
|
|
#else
|
2015-02-24 07:38:10 -06:00
|
|
|
#define START_ADC(pin) ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
|
|
|
|
2015-04-13 19:17:36 -05:00
|
|
|
// Prepare or measure a sensor, each one every 12th frame
|
2011-11-15 15:50:43 -06:00
|
|
|
switch(temp_state) {
|
2015-02-24 06:46:11 -06:00
|
|
|
case PrepareTemp_0:
|
|
|
|
#if HAS_TEMP_0
|
2015-02-24 07:38:10 -06:00
|
|
|
START_ADC(TEMP_0_PIN);
|
2011-11-15 15:50:43 -06:00
|
|
|
#endif
|
2012-12-03 05:52:00 -06:00
|
|
|
lcd_buttons_update();
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_state = MeasureTemp_0;
|
2011-11-15 15:50:43 -06:00
|
|
|
break;
|
2015-02-24 06:46:11 -06:00
|
|
|
case MeasureTemp_0:
|
|
|
|
#if HAS_TEMP_0
|
2015-03-21 16:23:43 -05:00
|
|
|
raw_temp_value[0] += ADC;
|
2011-11-15 15:50:43 -06:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_state = PrepareTemp_BED;
|
2011-11-15 15:50:43 -06:00
|
|
|
break;
|
2015-03-23 02:27:29 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
case PrepareTemp_BED:
|
|
|
|
#if HAS_TEMP_BED
|
2015-02-24 07:38:10 -06:00
|
|
|
START_ADC(TEMP_BED_PIN);
|
2011-12-05 22:33:33 -06:00
|
|
|
#endif
|
2012-12-03 05:52:00 -06:00
|
|
|
lcd_buttons_update();
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_state = MeasureTemp_BED;
|
2011-12-05 22:33:33 -06:00
|
|
|
break;
|
2015-02-24 06:46:11 -06:00
|
|
|
case MeasureTemp_BED:
|
|
|
|
#if HAS_TEMP_BED
|
2011-12-05 22:33:33 -06:00
|
|
|
raw_temp_bed_value += ADC;
|
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_state = PrepareTemp_1;
|
2011-12-05 22:33:33 -06:00
|
|
|
break;
|
2015-03-23 02:27:29 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
case PrepareTemp_1:
|
|
|
|
#if HAS_TEMP_1
|
2015-02-24 07:38:10 -06:00
|
|
|
START_ADC(TEMP_1_PIN);
|
2011-11-15 15:50:43 -06:00
|
|
|
#endif
|
2012-12-03 05:52:00 -06:00
|
|
|
lcd_buttons_update();
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_state = MeasureTemp_1;
|
2011-11-15 15:50:43 -06:00
|
|
|
break;
|
2015-02-24 06:46:11 -06:00
|
|
|
case MeasureTemp_1:
|
|
|
|
#if HAS_TEMP_1
|
2015-03-21 16:23:43 -05:00
|
|
|
raw_temp_value[1] += ADC;
|
2011-11-15 15:50:43 -06:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_state = PrepareTemp_2;
|
2011-11-15 15:50:43 -06:00
|
|
|
break;
|
2015-03-23 02:27:29 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
case PrepareTemp_2:
|
|
|
|
#if HAS_TEMP_2
|
2015-02-24 07:38:10 -06:00
|
|
|
START_ADC(TEMP_2_PIN);
|
2011-11-15 15:50:43 -06:00
|
|
|
#endif
|
2012-12-03 05:52:00 -06:00
|
|
|
lcd_buttons_update();
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_state = MeasureTemp_2;
|
2011-11-15 15:50:43 -06:00
|
|
|
break;
|
2015-02-24 06:46:11 -06:00
|
|
|
case MeasureTemp_2:
|
|
|
|
#if HAS_TEMP_2
|
2015-03-21 16:23:43 -05:00
|
|
|
raw_temp_value[2] += ADC;
|
2011-11-15 15:50:43 -06:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_state = PrepareTemp_3;
|
2011-11-15 15:50:43 -06:00
|
|
|
break;
|
2015-03-23 02:27:29 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
case PrepareTemp_3:
|
|
|
|
#if HAS_TEMP_3
|
2015-02-24 07:38:10 -06:00
|
|
|
START_ADC(TEMP_3_PIN);
|
2015-01-23 16:13:06 -06:00
|
|
|
#endif
|
|
|
|
lcd_buttons_update();
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_state = MeasureTemp_3;
|
2015-01-23 16:13:06 -06:00
|
|
|
break;
|
2015-02-24 06:46:11 -06:00
|
|
|
case MeasureTemp_3:
|
|
|
|
#if HAS_TEMP_3
|
2015-03-21 16:23:43 -05:00
|
|
|
raw_temp_value[3] += ADC;
|
2015-01-23 16:13:06 -06:00
|
|
|
#endif
|
2015-02-24 06:46:11 -06:00
|
|
|
temp_state = Prepare_FILWIDTH;
|
2015-01-23 16:13:06 -06:00
|
|
|
break;
|
2015-03-23 02:27:29 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
case Prepare_FILWIDTH:
|
|
|
|
#if HAS_FILAMENT_SENSOR
|
2015-02-24 07:38:10 -06:00
|
|
|
START_ADC(FILWIDTH_PIN);
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
|
|
|
lcd_buttons_update();
|
|
|
|
temp_state = Measure_FILWIDTH;
|
|
|
|
break;
|
|
|
|
case Measure_FILWIDTH:
|
|
|
|
#if HAS_FILAMENT_SENSOR
|
|
|
|
// raw_filwidth_value += ADC; //remove to use an IIR filter approach
|
|
|
|
if (ADC > 102) { //check that ADC is reading a voltage > 0.5 volts, otherwise don't take in the data.
|
|
|
|
raw_filwidth_value -= (raw_filwidth_value>>7); //multiply raw_filwidth_value by 127/128
|
|
|
|
raw_filwidth_value += ((unsigned long)ADC<<7); //add new ADC reading
|
2014-08-06 19:30:57 -05:00
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
|
|
|
temp_state = PrepareTemp_0;
|
|
|
|
temp_count++;
|
2014-01-06 04:20:03 -06:00
|
|
|
break;
|
2015-03-23 02:27:29 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
case StartupDelay:
|
|
|
|
temp_state = PrepareTemp_0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
// default:
|
|
|
|
// SERIAL_ERROR_START;
|
|
|
|
// SERIAL_ERRORLNPGM("Temp measurement error!");
|
|
|
|
// break;
|
|
|
|
} // switch(temp_state)
|
2015-03-23 02:27:29 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
if (temp_count >= OVERSAMPLENR) { // 10 * 16 * 1/(16000000/64/256) = 164ms.
|
2015-03-26 18:22:21 -05:00
|
|
|
// Update the raw values if they've been read. Else we could be updating them during reading.
|
|
|
|
if (!temp_meas_ready) set_current_temp_raw();
|
2014-08-06 19:30:57 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
// Filament Sensor - can be read any time since IIR filtering is used
|
|
|
|
#if HAS_FILAMENT_SENSOR
|
|
|
|
current_raw_filwidth = raw_filwidth_value >> 10; // Divide to get to 0-16384 range since we used 1/128 IIR filter approach
|
|
|
|
#endif
|
2015-03-23 02:27:29 -05:00
|
|
|
|
2011-11-15 15:50:43 -06:00
|
|
|
temp_count = 0;
|
2015-03-26 18:22:21 -05:00
|
|
|
for (int i = 0; i < 4; i++) raw_temp_value[i] = 0;
|
2011-12-05 22:33:33 -06:00
|
|
|
raw_temp_bed_value = 0;
|
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if HAS_TEMP_0 && DISABLED(HEATER_0_USES_MAX6675)
|
2015-04-06 23:28:14 -05:00
|
|
|
#if HEATER_0_RAW_LO_TEMP > HEATER_0_RAW_HI_TEMP
|
|
|
|
#define GE0 <=
|
|
|
|
#else
|
|
|
|
#define GE0 >=
|
|
|
|
#endif
|
|
|
|
if (current_temperature_raw[0] GE0 maxttemp_raw[0]) max_temp_error(0);
|
|
|
|
if (minttemp_raw[0] GE0 current_temperature_raw[0]) min_temp_error(0);
|
|
|
|
#endif
|
2015-03-21 16:23:43 -05:00
|
|
|
|
2015-07-14 21:51:26 -05:00
|
|
|
#if HAS_TEMP_1 && EXTRUDERS > 1
|
2015-03-21 16:23:43 -05:00
|
|
|
#if HEATER_1_RAW_LO_TEMP > HEATER_1_RAW_HI_TEMP
|
|
|
|
#define GE1 <=
|
|
|
|
#else
|
|
|
|
#define GE1 >=
|
|
|
|
#endif
|
2015-04-01 06:40:05 -05:00
|
|
|
if (current_temperature_raw[1] GE1 maxttemp_raw[1]) max_temp_error(1);
|
|
|
|
if (minttemp_raw[1] GE1 current_temperature_raw[1]) min_temp_error(1);
|
2015-03-31 19:56:14 -05:00
|
|
|
#endif // TEMP_SENSOR_1
|
2015-03-23 02:27:29 -05:00
|
|
|
|
2015-07-14 21:51:26 -05:00
|
|
|
#if HAS_TEMP_2 && EXTRUDERS > 2
|
2015-03-31 19:56:14 -05:00
|
|
|
#if HEATER_2_RAW_LO_TEMP > HEATER_2_RAW_HI_TEMP
|
|
|
|
#define GE2 <=
|
|
|
|
#else
|
|
|
|
#define GE2 >=
|
|
|
|
#endif
|
2015-04-04 00:09:31 -05:00
|
|
|
if (current_temperature_raw[2] GE2 maxttemp_raw[2]) max_temp_error(2);
|
2015-04-01 06:40:05 -05:00
|
|
|
if (minttemp_raw[2] GE2 current_temperature_raw[2]) min_temp_error(2);
|
2015-03-31 19:56:14 -05:00
|
|
|
#endif // TEMP_SENSOR_2
|
2015-03-23 02:27:29 -05:00
|
|
|
|
2015-07-14 21:51:26 -05:00
|
|
|
#if HAS_TEMP_3 && EXTRUDERS > 3
|
2015-03-31 19:56:14 -05:00
|
|
|
#if HEATER_3_RAW_LO_TEMP > HEATER_3_RAW_HI_TEMP
|
|
|
|
#define GE3 <=
|
|
|
|
#else
|
|
|
|
#define GE3 >=
|
|
|
|
#endif
|
2015-04-01 06:40:05 -05:00
|
|
|
if (current_temperature_raw[3] GE3 maxttemp_raw[3]) max_temp_error(3);
|
|
|
|
if (minttemp_raw[3] GE3 current_temperature_raw[3]) min_temp_error(3);
|
2015-03-31 19:56:14 -05:00
|
|
|
#endif // TEMP_SENSOR_3
|
2015-01-23 16:13:06 -06:00
|
|
|
|
2015-03-31 19:56:14 -05:00
|
|
|
#if HAS_TEMP_BED
|
2015-03-21 16:23:43 -05:00
|
|
|
#if HEATER_BED_RAW_LO_TEMP > HEATER_BED_RAW_HI_TEMP
|
|
|
|
#define GEBED <=
|
|
|
|
#else
|
|
|
|
#define GEBED >=
|
|
|
|
#endif
|
2015-05-25 06:23:19 -05:00
|
|
|
if (current_temperature_bed_raw GEBED bed_maxttemp_raw) _temp_error(-1, PSTR(MSG_T_MAXTEMP), PSTR(MSG_ERR_MAXTEMP_BED));
|
|
|
|
if (bed_minttemp_raw GEBED current_temperature_bed_raw) _temp_error(-1, PSTR(MSG_T_MINTEMP), PSTR(MSG_ERR_MINTEMP_BED));
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif
|
2015-03-21 16:23:43 -05:00
|
|
|
|
2015-02-24 06:46:11 -06:00
|
|
|
} // temp_count >= OVERSAMPLENR
|
2015-01-23 16:13:06 -06:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(BABYSTEPPING)
|
2015-04-13 19:17:36 -05:00
|
|
|
for (uint8_t axis = X_AXIS; axis <= Z_AXIS; axis++) {
|
|
|
|
int curTodo = babystepsTodo[axis]; //get rid of volatile for performance
|
2015-02-24 06:46:11 -06:00
|
|
|
|
|
|
|
if (curTodo > 0) {
|
|
|
|
babystep(axis,/*fwd*/true);
|
2015-04-13 19:17:36 -05:00
|
|
|
babystepsTodo[axis]--; //fewer to do next time
|
2015-02-24 06:46:11 -06:00
|
|
|
}
|
2015-04-13 19:17:36 -05:00
|
|
|
else if (curTodo < 0) {
|
2015-02-24 06:46:11 -06:00
|
|
|
babystep(axis,/*fwd*/false);
|
2015-04-13 19:17:36 -05:00
|
|
|
babystepsTodo[axis]++; //fewer to do next time
|
2015-02-24 06:46:11 -06:00
|
|
|
}
|
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 14:14:51 -05:00
|
|
|
}
|
2015-02-24 06:46:11 -06:00
|
|
|
#endif //BABYSTEPPING
|
2011-11-15 15:50:43 -06:00
|
|
|
}
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
2015-07-31 00:29:30 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
2015-02-24 06:46:11 -06:00
|
|
|
// Apply the scale factors to the PID values
|
|
|
|
float scalePID_i(float i) { return i * PID_dT; }
|
|
|
|
float unscalePID_i(float i) { return i / PID_dT; }
|
|
|
|
float scalePID_d(float d) { return d / PID_dT; }
|
|
|
|
float unscalePID_d(float d) { return d * PID_dT; }
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
#endif //PIDTEMP
|