SunRed/Marlin-Artillery-M600
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Cleanup of temperature code

Browse source 
- Reduce calls to millis()
- General cleanup of manage_heaters
- General cleanup of pid autotune
- Formatting here & there
- Macros to clean up and shrink ISR code (reduced by ~364 lines)
This commit is contained in:
Scott Lahteine 2015-02-24 04:46:11 -08:00
parent e6af82ba2f
commit 9c9726d469
3 changed files with 875 additions and 1268 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Marlin/pins_RUMBA.h
View file

@ -6,6 +6,10 @@
#error Oops! Make sure you have 'Arduino Mega' selected from the 'Tools -> Boards' menu. #error Oops! Make sure you have 'Arduino Mega' selected from the 'Tools -> Boards' menu.
#endif #endif
#if EXTRUDERS > 3
#error RUMBA supports up to 3 extruders. Comment this line to keep going.
#endif
#define X_STEP_PIN 17 #define X_STEP_PIN 17
#define X_DIR_PIN 16 #define X_DIR_PIN 16
#define X_ENABLE_PIN 48 #define X_ENABLE_PIN 48

1586
Marlin/temperature.cpp
View file

@ -71,7 +71,7 @@ float current_temperature_bed = 0.0;
unsigned char soft_pwm_bed; unsigned char soft_pwm_bed;
#ifdef BABYSTEPPING #ifdef BABYSTEPPING
volatile int babystepsTodo[3]={0,0,0}; volatile int babystepsTodo[3] = { 0 };
#endif #endif
#ifdef FILAMENT_SENSOR #ifdef FILAMENT_SENSOR
@ -123,33 +123,33 @@ static volatile bool temp_meas_ready = false;
#endif #endif
#if EXTRUDERS > 4 #if EXTRUDERS > 4
# error Unsupported number of extruders #error Unsupported number of extruders
#elif EXTRUDERS > 3 #elif EXTRUDERS > 3
# define ARRAY_BY_EXTRUDERS(v1, v2, v3, v4) { v1, v2, v3, v4 } #define ARRAY_BY_EXTRUDERS(v1, v2, v3, v4) { v1, v2, v3, v4 }
#elif EXTRUDERS > 2 #elif EXTRUDERS > 2
# define ARRAY_BY_EXTRUDERS(v1, v2, v3, v4) { v1, v2, v3 } #define ARRAY_BY_EXTRUDERS(v1, v2, v3, v4) { v1, v2, v3 }
#elif EXTRUDERS > 1 #elif EXTRUDERS > 1
# define ARRAY_BY_EXTRUDERS(v1, v2, v3, v4) { v1, v2 } #define ARRAY_BY_EXTRUDERS(v1, v2, v3, v4) { v1, v2 }
#else #else
# define ARRAY_BY_EXTRUDERS(v1, v2, v3, v4) { v1 } #define ARRAY_BY_EXTRUDERS(v1, v2, v3, v4) { v1 }
#endif #endif
#ifdef PIDTEMP #ifdef PIDTEMP
#ifdef PID_PARAMS_PER_EXTRUDER #ifdef PID_PARAMS_PER_EXTRUDER
float Kp[EXTRUDERS] = ARRAY_BY_EXTRUDERS(DEFAULT_Kp, DEFAULT_Kp, DEFAULT_Kp, DEFAULT_Kp); float Kp[EXTRUDERS] = ARRAY_BY_EXTRUDERS(DEFAULT_Kp, DEFAULT_Kp, DEFAULT_Kp, DEFAULT_Kp);
float Ki[EXTRUDERS] = ARRAY_BY_EXTRUDERS(DEFAULT_Ki*PID_dT, DEFAULT_Ki*PID_dT, DEFAULT_Ki*PID_dT, DEFAULT_Ki*PID_dT); float Ki[EXTRUDERS] = ARRAY_BY_EXTRUDERS(DEFAULT_Ki*PID_dT, DEFAULT_Ki*PID_dT, DEFAULT_Ki*PID_dT, DEFAULT_Ki*PID_dT);
float Kd[EXTRUDERS] = ARRAY_BY_EXTRUDERS(DEFAULT_Kd / PID_dT, DEFAULT_Kd / PID_dT, DEFAULT_Kd / PID_dT, DEFAULT_Kd / PID_dT); float Kd[EXTRUDERS] = ARRAY_BY_EXTRUDERS(DEFAULT_Kd / PID_dT, DEFAULT_Kd / PID_dT, DEFAULT_Kd / PID_dT, DEFAULT_Kd / PID_dT);
#ifdef PID_ADD_EXTRUSION_RATE #ifdef PID_ADD_EXTRUSION_RATE
float Kc[EXTRUDERS] = ARRAY_BY_EXTRUDERS(DEFAULT_Kc, DEFAULT_Kc, DEFAULT_Kc, DEFAULT_Kc); float Kc[EXTRUDERS] = ARRAY_BY_EXTRUDERS(DEFAULT_Kc, DEFAULT_Kc, DEFAULT_Kc, DEFAULT_Kc);
#endif // PID_ADD_EXTRUSION_RATE #endif // PID_ADD_EXTRUSION_RATE
#else //PID_PARAMS_PER_EXTRUDER #else //PID_PARAMS_PER_EXTRUDER
float Kp = DEFAULT_Kp; float Kp = DEFAULT_Kp;
float Ki = DEFAULT_Ki * PID_dT; float Ki = DEFAULT_Ki * PID_dT;
float Kd = DEFAULT_Kd / PID_dT; float Kd = DEFAULT_Kd / PID_dT;
#ifdef PID_ADD_EXTRUSION_RATE #ifdef PID_ADD_EXTRUSION_RATE
float Kc = DEFAULT_Kc; float Kc = DEFAULT_Kc;
#endif // PID_ADD_EXTRUSION_RATE #endif // PID_ADD_EXTRUSION_RATE
#endif // PID_PARAMS_PER_EXTRUDER #endif // PID_PARAMS_PER_EXTRUDER
#endif //PIDTEMP #endif //PIDTEMP
// Init min and max temp with extreme values to prevent false errors during startup // Init min and max temp with extreme values to prevent false errors during startup
@ -159,7 +159,7 @@ static int minttemp[EXTRUDERS] = ARRAY_BY_EXTRUDERS( 0, 0, 0, 0 );
static int maxttemp[EXTRUDERS] = ARRAY_BY_EXTRUDERS( 16383, 16383, 16383, 16383 ); static int maxttemp[EXTRUDERS] = ARRAY_BY_EXTRUDERS( 16383, 16383, 16383, 16383 );
//static int bed_minttemp_raw = HEATER_BED_RAW_LO_TEMP; /* No bed mintemp error implemented?!? */ //static int bed_minttemp_raw = HEATER_BED_RAW_LO_TEMP; /* No bed mintemp error implemented?!? */
#ifdef BED_MAXTEMP #ifdef BED_MAXTEMP
static int bed_maxttemp_raw = HEATER_BED_RAW_HI_TEMP; static int bed_maxttemp_raw = HEATER_BED_RAW_HI_TEMP;
#endif #endif
#ifdef TEMP_SENSOR_1_AS_REDUNDANT #ifdef TEMP_SENSOR_1_AS_REDUNDANT
@ -175,12 +175,12 @@ static float analog2tempBed(int raw);
static void updateTemperaturesFromRawValues(); static void updateTemperaturesFromRawValues();
#ifdef WATCH_TEMP_PERIOD #ifdef WATCH_TEMP_PERIOD
int watch_start_temp[EXTRUDERS] = ARRAY_BY_EXTRUDERS(0,0,0,0); int watch_start_temp[EXTRUDERS] = ARRAY_BY_EXTRUDERS(0,0,0,0);
unsigned long watchmillis[EXTRUDERS] = ARRAY_BY_EXTRUDERS(0,0,0,0); unsigned long watchmillis[EXTRUDERS] = ARRAY_BY_EXTRUDERS(0,0,0,0);
#endif //WATCH_TEMP_PERIOD #endif //WATCH_TEMP_PERIOD
#ifndef SOFT_PWM_SCALE #ifndef SOFT_PWM_SCALE
#define SOFT_PWM_SCALE 0 #define SOFT_PWM_SCALE 0
#endif #endif
#ifdef FILAMENT_SENSOR #ifdef FILAMENT_SENSOR
@ -191,6 +191,13 @@ unsigned long watchmillis[EXTRUDERS] = ARRAY_BY_EXTRUDERS(0,0,0,0);
static int read_max6675(); static int read_max6675();
#endif #endif
#define HAS_TEMP_0 (defined(TEMP_0_PIN) && TEMP_0_PIN > -1)
#define HAS_TEMP_1 (defined(TEMP_1_PIN) && TEMP_1_PIN > -1)
#define HAS_TEMP_2 (defined(TEMP_2_PIN) && TEMP_2_PIN > -1)
#define HAS_TEMP_3 (defined(TEMP_3_PIN) && TEMP_3_PIN > -1)
#define HAS_TEMP_BED (defined(TEMP_BED_PIN) && TEMP_BED_PIN > -1)
#define HAS_FILAMENT_SENSOR (defined(FILAMENT_SENSOR) && defined(FILWIDTH_PIN) && FILWIDTH_PIN > -1)
//=========================================================================== //===========================================================================
//============================= functions ============================ //============================= functions ============================
//=========================================================================== //===========================================================================
@ -198,32 +205,29 @@ unsigned long watchmillis[EXTRUDERS] = ARRAY_BY_EXTRUDERS(0,0,0,0);
void PID_autotune(float temp, int extruder, int ncycles) void PID_autotune(float temp, int extruder, int ncycles)
{ {
float input = 0.0; float input = 0.0;
int cycles=0; int cycles = 0;
bool heating = true; bool heating = true;
unsigned long temp_millis = millis(); unsigned long temp_millis = millis(), t1 = temp_millis, t2 = temp_millis;
unsigned long t1=temp_millis; long t_high = 0, t_low = 0;
unsigned long t2=temp_millis;
long t_high = 0;
long t_low = 0;
long bias, d; long bias, d;
float Ku, Tu; float Ku, Tu;
float Kp, Ki, Kd; float Kp, Ki, Kd;
float max = 0, min = 10000; float max = 0, min = 10000;
#if (defined(EXTRUDER_0_AUTO_FAN_PIN) && EXTRUDER_0_AUTO_FAN_PIN > -1) || \ #if (defined(EXTRUDER_0_AUTO_FAN_PIN) && EXTRUDER_0_AUTO_FAN_PIN > -1) || \
(defined(EXTRUDER_1_AUTO_FAN_PIN) && EXTRUDER_1_AUTO_FAN_PIN > -1) || \ (defined(EXTRUDER_1_AUTO_FAN_PIN) && EXTRUDER_1_AUTO_FAN_PIN > -1) || \
(defined(EXTRUDER_2_AUTO_FAN_PIN) && EXTRUDER_2_AUTO_FAN_PIN > -1) || \ (defined(EXTRUDER_2_AUTO_FAN_PIN) && EXTRUDER_2_AUTO_FAN_PIN > -1) || \
(defined(EXTRUDER_3_AUTO_FAN_PIN) && EXTRUDER_3_AUTO_FAN_PIN > -1) (defined(EXTRUDER_3_AUTO_FAN_PIN) && EXTRUDER_3_AUTO_FAN_PIN > -1)
unsigned long extruder_autofan_last_check = millis(); unsigned long extruder_autofan_last_check = temp_millis;
#endif
if ((extruder >= EXTRUDERS)
#if (TEMP_BED_PIN <= -1)
||(extruder < 0)
#endif #endif
){
if (extruder >= EXTRUDERS
#if !HAS_TEMP_BED
|| extruder < 0
#endif
) {
SERIAL_ECHOLN("PID Autotune failed. Bad extruder number."); SERIAL_ECHOLN("PID Autotune failed. Bad extruder number.");
return; return;
} }
@ -232,75 +236,69 @@ void PID_autotune(float temp, int extruder, int ncycles)
disable_heater(); // switch off all heaters. disable_heater(); // switch off all heaters.
if (extruder<0) if (extruder < 0)
{ soft_pwm_bed = bias = d = MAX_BED_POWER / 2;
soft_pwm_bed = (MAX_BED_POWER)/2;
bias = d = (MAX_BED_POWER)/2;
}
else else
{ soft_pwm[extruder] = bias = d = PID_MAX / 2;
soft_pwm[extruder] = (PID_MAX)/2;
bias = d = (PID_MAX)/2;
}
// PID Tuning loop
for(;;) { for(;;) {
if(temp_meas_ready == true) { // temp sample ready unsigned long ms = millis();
if (temp_meas_ready == true) { // temp sample ready
updateTemperaturesFromRawValues(); updateTemperaturesFromRawValues();
input = (extruder<0)?current_temperature_bed:current_temperature[extruder]; input = (extruder<0)?current_temperature_bed:current_temperature[extruder];
max=max(max,input); max = max(max, input);
min=min(min,input); min = min(min, input);
#if (defined(EXTRUDER_0_AUTO_FAN_PIN) && EXTRUDER_0_AUTO_FAN_PIN > -1) || \ #if (defined(EXTRUDER_0_AUTO_FAN_PIN) && EXTRUDER_0_AUTO_FAN_PIN > -1) || \
(defined(EXTRUDER_1_AUTO_FAN_PIN) && EXTRUDER_1_AUTO_FAN_PIN > -1) || \ (defined(EXTRUDER_1_AUTO_FAN_PIN) && EXTRUDER_1_AUTO_FAN_PIN > -1) || \
(defined(EXTRUDER_2_AUTO_FAN_PIN) && EXTRUDER_2_AUTO_FAN_PIN > -1) || \ (defined(EXTRUDER_2_AUTO_FAN_PIN) && EXTRUDER_2_AUTO_FAN_PIN > -1) || \
(defined(EXTRUDER_3_AUTO_FAN_PIN) && EXTRUDER_3_AUTO_FAN_PIN > -1) (defined(EXTRUDER_3_AUTO_FAN_PIN) && EXTRUDER_3_AUTO_FAN_PIN > -1)
if(millis() - extruder_autofan_last_check > 2500) { if (ms > extruder_autofan_last_check + 2500) {
checkExtruderAutoFans(); checkExtruderAutoFans();
extruder_autofan_last_check = millis(); extruder_autofan_last_check = ms;
} }
#endif #endif
if(heating == true && input > temp) { if (heating == true && input > temp) {
if(millis() - t2 > 5000) { if (ms - t2 > 5000) {
heating=false; heating = false;
if (extruder<0) if (extruder < 0)
soft_pwm_bed = (bias - d) >> 1; soft_pwm_bed = (bias - d) >> 1;
else else
soft_pwm[extruder] = (bias - d) >> 1; soft_pwm[extruder] = (bias - d) >> 1;
t1=millis(); t1 = ms;
t_high=t1 - t2; t_high = t1 - t2;
max=temp; max = temp;
} }
} }
if(heating == false && input < temp) { if (heating == false && input < temp) {
if(millis() - t1 > 5000) { if (ms - t1 > 5000) {
heating=true; heating = true;
t2=millis(); t2 = ms;
t_low=t2 - t1; t_low = t2 - t1;
if(cycles > 0) { if (cycles > 0) {
long max_pow = extruder < 0 ? MAX_BED_POWER : PID_MAX;
bias += (d*(t_high - t_low))/(t_low + t_high); bias += (d*(t_high - t_low))/(t_low + t_high);
bias = constrain(bias, 20 ,(extruder<0?(MAX_BED_POWER):(PID_MAX))-20); bias = constrain(bias, 20, max_pow - 20);
if(bias > (extruder<0?(MAX_BED_POWER):(PID_MAX))/2) d = (extruder<0?(MAX_BED_POWER):(PID_MAX)) - 1 - bias; d = (bias > max_pow / 2) ? max_pow - 1 - bias : bias;
else d = bias;
SERIAL_PROTOCOLPGM(" bias: "); SERIAL_PROTOCOL(bias); SERIAL_PROTOCOLPGM(" bias: "); SERIAL_PROTOCOL(bias);
SERIAL_PROTOCOLPGM(" d: "); SERIAL_PROTOCOL(d); SERIAL_PROTOCOLPGM(" d: "); SERIAL_PROTOCOL(d);
SERIAL_PROTOCOLPGM(" min: "); SERIAL_PROTOCOL(min); SERIAL_PROTOCOLPGM(" min: "); SERIAL_PROTOCOL(min);
SERIAL_PROTOCOLPGM(" max: "); SERIAL_PROTOCOLLN(max); SERIAL_PROTOCOLPGM(" max: "); SERIAL_PROTOCOLLN(max);
if(cycles > 2) { if (cycles > 2) {
Ku = (4.0*d)/(3.14159*(max-min)/2.0); Ku = (4.0 * d) / (3.14159265 * (max - min) / 2.0);
Tu = ((float)(t_low + t_high)/1000.0); Tu = ((float)(t_low + t_high) / 1000.0);
SERIAL_PROTOCOLPGM(" Ku: "); SERIAL_PROTOCOL(Ku); SERIAL_PROTOCOLPGM(" Ku: "); SERIAL_PROTOCOL(Ku);
SERIAL_PROTOCOLPGM(" Tu: "); SERIAL_PROTOCOLLN(Tu); SERIAL_PROTOCOLPGM(" Tu: "); SERIAL_PROTOCOLLN(Tu);
Kp = 0.6*Ku; Kp = 0.6 * Ku;
Ki = 2*Kp/Tu; Ki = 2 * Kp / Tu;
Kd = Kp*Tu/8; Kd = Kp * Tu / 8;
SERIAL_PROTOCOLLNPGM(" Classic PID "); SERIAL_PROTOCOLLNPGM(" Classic PID ");
SERIAL_PROTOCOLPGM(" Kp: "); SERIAL_PROTOCOLLN(Kp); SERIAL_PROTOCOLPGM(" Kp: "); SERIAL_PROTOCOLLN(Kp);
SERIAL_PROTOCOLPGM(" Ki: "); SERIAL_PROTOCOLLN(Ki); SERIAL_PROTOCOLPGM(" Ki: "); SERIAL_PROTOCOLLN(Ki);
@ -323,26 +321,28 @@ void PID_autotune(float temp, int extruder, int ncycles)
*/ */
} }
} }
if (extruder<0) if (extruder < 0)
soft_pwm_bed = (bias + d) >> 1; soft_pwm_bed = (bias + d) >> 1;
else else
soft_pwm[extruder] = (bias + d) >> 1; soft_pwm[extruder] = (bias + d) >> 1;
cycles++; cycles++;
min=temp; min = temp;
} }
} }
} }
if(input > (temp + 20)) { if (input > temp + 20) {
SERIAL_PROTOCOLLNPGM("PID Autotune failed! Temperature too high"); SERIAL_PROTOCOLLNPGM("PID Autotune failed! Temperature too high");
return; return;
} }
if(millis() - temp_millis > 2000) { // Every 2 seconds...
if (ms - temp_millis > 2000) {
int p; int p;
if (extruder<0){ if (extruder < 0) {
p=soft_pwm_bed; p = soft_pwm_bed;
SERIAL_PROTOCOLPGM("ok B:"); SERIAL_PROTOCOLPGM("ok B:");
}else{ }
p=soft_pwm[extruder]; else {
p = soft_pwm[extruder];
SERIAL_PROTOCOLPGM("ok T:"); SERIAL_PROTOCOLPGM("ok T:");
} }
@ -350,13 +350,14 @@ void PID_autotune(float temp, int extruder, int ncycles)
SERIAL_PROTOCOLPGM(" @:"); SERIAL_PROTOCOLPGM(" @:");
SERIAL_PROTOCOLLN(p); SERIAL_PROTOCOLLN(p);
temp_millis = millis(); temp_millis = ms;
} } // every 2 seconds
if(((millis() - t1) + (millis() - t2)) > (10L*60L*1000L*2L)) { // Over 2 minutes?
if (((ms - t1) + (ms - t2)) > (10L*60L*1000L*2L)) {
SERIAL_PROTOCOLLNPGM("PID Autotune failed! timeout"); SERIAL_PROTOCOLLNPGM("PID Autotune failed! timeout");
return; return;
} }
if(cycles > ncycles) { if (cycles > ncycles) {
SERIAL_PROTOCOLLNPGM("PID Autotune finished! Put the last Kp, Ki and Kd constants from above into Configuration.h"); SERIAL_PROTOCOLLNPGM("PID Autotune finished! Put the last Kp, Ki and Kd constants from above into Configuration.h");
return; return;
} }
@ -364,22 +365,19 @@ void PID_autotune(float temp, int extruder, int ncycles)
} }
} }
void updatePID() void updatePID() {
{ #ifdef PIDTEMP
#ifdef PIDTEMP for (int e = 0; e < EXTRUDERS; e++) {
for(int e = 0; e < EXTRUDERS; e++) {
temp_iState_max[e] = PID_INTEGRAL_DRIVE_MAX / PID_PARAM(Ki,e); temp_iState_max[e] = PID_INTEGRAL_DRIVE_MAX / PID_PARAM(Ki,e);
} }
#endif #endif
#ifdef PIDTEMPBED #ifdef PIDTEMPBED
temp_iState_max_bed = PID_INTEGRAL_DRIVE_MAX / bedKi; temp_iState_max_bed = PID_INTEGRAL_DRIVE_MAX / bedKi;
#endif #endif
} }
int getHeaterPower(int heater) { int getHeaterPower(int heater) {
if (heater<0) return heater < 0 ? soft_pwm_bed : soft_pwm[heater];
return soft_pwm_bed;
return soft_pwm[heater];
} }
#if (defined(EXTRUDER_0_AUTO_FAN_PIN) && EXTRUDER_0_AUTO_FAN_PIN > -1) || \ #if (defined(EXTRUDER_0_AUTO_FAN_PIN) && EXTRUDER_0_AUTO_FAN_PIN > -1) || \
@ -473,29 +471,60 @@ void checkExtruderAutoFans()
#endif // any extruder auto fan pins set #endif // any extruder auto fan pins set
void manage_heater() //
{ // Error checking and Write Routines
float pid_input; //
float pid_output; #if !defined(HEATER_0_PIN) || HEATER_0_PIN < 0
#error HEATER_0_PIN not defined for this board
#endif
#define WRITE_HEATER_0P(v) WRITE(HEATER_0_PIN, v)
#if EXTRUDERS > 1 || defined(HEATERS_PARALLEL)
#if !defined(HEATER_1_PIN) || HEATER_1_PIN < 0
#error HEATER_1_PIN not defined for this board
#endif
#define WRITE_HEATER_1(v) WRITE(HEATER_1_PIN, v)
#if EXTRUDERS > 2
#if !defined(HEATER_2_PIN) || HEATER_2_PIN < 0
#error HEATER_2_PIN not defined for this board
#endif
#define WRITE_HEATER_2(v) WRITE(HEATER_2_PIN, v)
#if EXTRUDERS > 3
#if !defined(HEATER_3_PIN) || HEATER_3_PIN < 0
#error HEATER_3_PIN not defined for this board
#endif
#define WRITE_HEATER_3(v) WRITE(HEATER_3_PIN, v)
#endif
#endif
#endif
#ifdef HEATERS_PARALLEL
#define WRITE_HEATER_0(v) { WRITE_HEATER_0P(v); WRITE_HEATER_1(v); }
#else
#define WRITE_HEATER_0(v) WRITE_HEATER_0P(v)
#endif
#if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
#define WRITE_HEATER_BED(v) WRITE(HEATER_BED_PIN, v)
#endif
if(temp_meas_ready != true) //better readability void manage_heater() {
return;
if (!temp_meas_ready) return;
float pid_input, pid_output;
updateTemperaturesFromRawValues(); updateTemperaturesFromRawValues();
#ifdef HEATER_0_USES_MAX6675 #ifdef HEATER_0_USES_MAX6675
if (current_temperature[0] > 1023 || current_temperature[0] > HEATER_0_MAXTEMP) { float ct = current_temperature[0];
max_temp_error(0); if (ct > min(HEATER_0_MAXTEMP, 1023)) max_temp_error(0);
} if (ct < max(HEATER_0_MINTEMP, 0.01)) min_temp_error(0);
if (current_temperature[0] == 0 || current_temperature[0] < HEATER_0_MINTEMP) {
min_temp_error(0);
}
#endif //HEATER_0_USES_MAX6675 #endif //HEATER_0_USES_MAX6675
for(int e = 0; e < EXTRUDERS; e++) unsigned long ms = millis();
{
#if defined (THERMAL_RUNAWAY_PROTECTION_PERIOD) && THERMAL_RUNAWAY_PROTECTION_PERIOD > 0 // Loop through all extruders
for (int e = 0; e < EXTRUDERS; e++) {
#if defined (THERMAL_RUNAWAY_PROTECTION_PERIOD) && THERMAL_RUNAWAY_PROTECTION_PERIOD > 0
thermal_runaway_protection(&thermal_runaway_state_machine[e], &thermal_runaway_timer[e], current_temperature[e], target_temperature[e], e, THERMAL_RUNAWAY_PROTECTION_PERIOD, THERMAL_RUNAWAY_PROTECTION_HYSTERESIS); thermal_runaway_protection(&thermal_runaway_state_machine[e], &thermal_runaway_timer[e], current_temperature[e], target_temperature[e], e, THERMAL_RUNAWAY_PROTECTION_PERIOD, THERMAL_RUNAWAY_PROTECTION_HYSTERESIS);
#endif #endif
@ -504,16 +533,16 @@ void manage_heater()
#ifndef PID_OPENLOOP #ifndef PID_OPENLOOP
pid_error[e] = target_temperature[e] - pid_input; pid_error[e] = target_temperature[e] - pid_input;
if(pid_error[e] > PID_FUNCTIONAL_RANGE) { if (pid_error[e] > PID_FUNCTIONAL_RANGE) {
pid_output = BANG_MAX; pid_output = BANG_MAX;
pid_reset[e] = true; pid_reset[e] = true;
} }
else if(pid_error[e] < -PID_FUNCTIONAL_RANGE || target_temperature[e] == 0) { else if (pid_error[e] < -PID_FUNCTIONAL_RANGE || target_temperature[e] == 0) {
pid_output = 0; pid_output = 0;
pid_reset[e] = true; pid_reset[e] = true;
} }
else { else {
if(pid_reset[e] == true) { if (pid_reset[e] == true) {
temp_iState[e] = 0.0; temp_iState[e] = 0.0;
pid_reset[e] = false; pid_reset[e] = false;
} }
@ -524,20 +553,22 @@ void manage_heater()
//K1 defined in Configuration.h in the PID settings //K1 defined in Configuration.h in the PID settings
#define K2 (1.0-K1) #define K2 (1.0-K1)
dTerm[e] = (PID_PARAM(Kd,e) * (pid_input - temp_dState[e]))*K2 + (K1 * dTerm[e]); dTerm[e] = (PID_PARAM(Kd,e) * (pid_input - temp_dState[e])) * K2 + (K1 * dTerm[e]);
pid_output = pTerm[e] + iTerm[e] - dTerm[e]; pid_output = pTerm[e] + iTerm[e] - dTerm[e];
if (pid_output > PID_MAX) { if (pid_output > PID_MAX) {
if (pid_error[e] > 0 ) temp_iState[e] -= pid_error[e]; // conditional un-integration if (pid_error[e] > 0) temp_iState[e] -= pid_error[e]; // conditional un-integration
pid_output=PID_MAX; pid_output = PID_MAX;
} else if (pid_output < 0){ }
if (pid_error[e] < 0 ) temp_iState[e] -= pid_error[e]; // conditional un-integration else if (pid_output < 0) {
pid_output=0; if (pid_error[e] < 0) temp_iState[e] -= pid_error[e]; // conditional un-integration
pid_output = 0;
} }
} }
temp_dState[e] = pid_input; temp_dState[e] = pid_input;
#else #else
pid_output = constrain(target_temperature[e], 0, PID_MAX); pid_output = constrain(target_temperature[e], 0, PID_MAX);
#endif //PID_OPENLOOP #endif //PID_OPENLOOP
#ifdef PID_DEBUG #ifdef PID_DEBUG
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHO(" PID_DEBUG "); SERIAL_ECHO(" PID_DEBUG ");
@ -553,40 +584,35 @@ void manage_heater()
SERIAL_ECHO(" dTerm "); SERIAL_ECHO(" dTerm ");
SERIAL_ECHOLN(dTerm[e]); SERIAL_ECHOLN(dTerm[e]);
#endif //PID_DEBUG #endif //PID_DEBUG
#else /* PID off */ #else /* PID off */
pid_output = 0; pid_output = 0;
if(current_temperature[e] < target_temperature[e]) { if (current_temperature[e] < target_temperature[e]) pid_output = PID_MAX;
pid_output = PID_MAX;
}
#endif #endif
// Check if temperature is within the correct range // Check if temperature is within the correct range
if((current_temperature[e] > minttemp[e]) && (current_temperature[e] < maxttemp[e])) soft_pwm[e] = current_temperature[e] > minttemp[e] && current_temperature[e] < maxttemp[e] ? (int)pid_output >> 1 : 0;
{
soft_pwm[e] = (int)pid_output >> 1;
}
else {
soft_pwm[e] = 0;
}
#ifdef WATCH_TEMP_PERIOD #ifdef WATCH_TEMP_PERIOD
if(watchmillis[e] && millis() - watchmillis[e] > WATCH_TEMP_PERIOD) if (watchmillis[e] && ms > watchmillis[e] + WATCH_TEMP_PERIOD) {
{ if (degHotend(e) < watch_start_temp[e] + WATCH_TEMP_INCREASE) {
if(degHotend(e) < watch_start_temp[e] + WATCH_TEMP_INCREASE)
{
setTargetHotend(0, e); setTargetHotend(0, e);
LCD_MESSAGEPGM("Heating failed"); LCD_MESSAGEPGM("Heating failed");
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOLN("Heating failed"); SERIAL_ECHOLNPGM("Heating failed");
}else{ }
else {
watchmillis[e] = 0; watchmillis[e] = 0;
} }
} }
#endif #endif //WATCH_TEMP_PERIOD
#ifdef TEMP_SENSOR_1_AS_REDUNDANT #ifdef TEMP_SENSOR_1_AS_REDUNDANT
if(fabs(current_temperature[0] - redundant_temperature) > MAX_REDUNDANT_TEMP_SENSOR_DIFF) { if (fabs(current_temperature[0] - redundant_temperature) > MAX_REDUNDANT_TEMP_SENSOR_DIFF) {
disable_heater(); disable_heater();
if(IsStopped() == false) { if (IsStopped() == false) {
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Extruder switched off. Temperature difference between temp sensors is too high !"); SERIAL_ERRORLNPGM("Extruder switched off. Temperature difference between temp sensors is too high !");
LCD_ALERTMESSAGEPGM("Err: REDUNDANT TEMP ERROR"); LCD_ALERTMESSAGEPGM("Err: REDUNDANT TEMP ERROR");
@ -595,24 +621,23 @@ void manage_heater()
Stop(); Stop();
#endif #endif
} }
#endif #endif //TEMP_SENSOR_1_AS_REDUNDANT
} // End extruder for loop
} // Extruders Loop
#if (defined(EXTRUDER_0_AUTO_FAN_PIN) && EXTRUDER_0_AUTO_FAN_PIN > -1) || \ #if (defined(EXTRUDER_0_AUTO_FAN_PIN) && EXTRUDER_0_AUTO_FAN_PIN > -1) || \
(defined(EXTRUDER_1_AUTO_FAN_PIN) && EXTRUDER_1_AUTO_FAN_PIN > -1) || \ (defined(EXTRUDER_1_AUTO_FAN_PIN) && EXTRUDER_1_AUTO_FAN_PIN > -1) || \
(defined(EXTRUDER_2_AUTO_FAN_PIN) && EXTRUDER_2_AUTO_FAN_PIN > -1) (defined(EXTRUDER_2_AUTO_FAN_PIN) && EXTRUDER_2_AUTO_FAN_PIN > -1)
if(millis() - extruder_autofan_last_check > 2500) // only need to check fan state very infrequently if (ms > extruder_autofan_last_check + 2500) { // only need to check fan state very infrequently
{
checkExtruderAutoFans(); checkExtruderAutoFans();
extruder_autofan_last_check = millis(); extruder_autofan_last_check = ms;
} }
#endif #endif
#ifndef PIDTEMPBED #ifndef PIDTEMPBED
if(millis() - previous_millis_bed_heater < BED_CHECK_INTERVAL) if (ms < previous_millis_bed_heater + BED_CHECK_INTERVAL) return;
return; previous_millis_bed_heater = ms;
previous_millis_bed_heater = millis(); #endif //PIDTEMPBED
#endif
#if TEMP_SENSOR_BED != 0 #if TEMP_SENSOR_BED != 0
@ -632,90 +657,63 @@ void manage_heater()
//K1 defined in Configuration.h in the PID settings //K1 defined in Configuration.h in the PID settings
#define K2 (1.0-K1) #define K2 (1.0-K1)
dTerm_bed= (bedKd * (pid_input - temp_dState_bed))*K2 + (K1 * dTerm_bed); dTerm_bed = (bedKd * (pid_input - temp_dState_bed))*K2 + (K1 * dTerm_bed);
temp_dState_bed = pid_input; temp_dState_bed = pid_input;
pid_output = pTerm_bed + iTerm_bed - dTerm_bed; pid_output = pTerm_bed + iTerm_bed - dTerm_bed;
if (pid_output > MAX_BED_POWER) { if (pid_output > MAX_BED_POWER) {
if (pid_error_bed > 0 ) temp_iState_bed -= pid_error_bed; // conditional un-integration if (pid_error_bed > 0) temp_iState_bed -= pid_error_bed; // conditional un-integration
pid_output=MAX_BED_POWER; pid_output = MAX_BED_POWER;
} else if (pid_output < 0){ }
if (pid_error_bed < 0 ) temp_iState_bed -= pid_error_bed; // conditional un-integration else if (pid_output < 0) {
pid_output=0; if (pid_error_bed < 0) temp_iState_bed -= pid_error_bed; // conditional un-integration
pid_output = 0;
} }
#else #else
pid_output = constrain(target_temperature_bed, 0, MAX_BED_POWER); pid_output = constrain(target_temperature_bed, 0, MAX_BED_POWER);
#endif //PID_OPENLOOP #endif //PID_OPENLOOP
if((current_temperature_bed > BED_MINTEMP) && (current_temperature_bed < BED_MAXTEMP)) soft_pwm_bed = current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP ? (int)pid_output >> 1 : 0;
{
soft_pwm_bed = (int)pid_output >> 1;
}
else {
soft_pwm_bed = 0;
}
#elif !defined(BED_LIMIT_SWITCHING) #elif !defined(BED_LIMIT_SWITCHING)
// Check if temperature is within the correct range // Check if temperature is within the correct range
if((current_temperature_bed > BED_MINTEMP) && (current_temperature_bed < BED_MAXTEMP)) if (current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP) {
{ soft_pwm_bed = current_temperature_bed >= target_temperature_bed ? 0 : MAX_BED_POWER >> 1;
if(current_temperature_bed >= target_temperature_bed) }
{ else {
soft_pwm_bed = 0; soft_pwm_bed = 0;
} WRITE_HEATER_BED(LOW);
else
{
soft_pwm_bed = MAX_BED_POWER>>1;
}
}
else
{
soft_pwm_bed = 0;
WRITE(HEATER_BED_PIN,LOW);
} }
#else //#ifdef BED_LIMIT_SWITCHING #else //#ifdef BED_LIMIT_SWITCHING
// Check if temperature is within the correct band // Check if temperature is within the correct band
if((current_temperature_bed > BED_MINTEMP) && (current_temperature_bed < BED_MAXTEMP)) if (current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP) {
{ if (current_temperature_bed >= target_temperature_bed + BED_HYSTERESIS)
if(current_temperature_bed > target_temperature_bed + BED_HYSTERESIS)
{
soft_pwm_bed = 0; soft_pwm_bed = 0;
else if (current_temperature_bed <= target_temperature_bed - BED_HYSTERESIS)
soft_pwm_bed = MAX_BED_POWER >> 1;
} }
else if(current_temperature_bed <= target_temperature_bed - BED_HYSTERESIS) else {
{
soft_pwm_bed = MAX_BED_POWER>>1;
}
}
else
{
soft_pwm_bed = 0; soft_pwm_bed = 0;
WRITE(HEATER_BED_PIN,LOW); WRITE_HEATER_BED(LOW);
} }
#endif #endif
#endif #endif //TEMP_SENSOR_BED != 0
//code for controlling the extruder rate based on the width sensor // Control the extruder rate based on the width sensor
#ifdef FILAMENT_SENSOR #ifdef FILAMENT_SENSOR
if(filament_sensor) if (filament_sensor) {
{ meas_shift_index = delay_index1 - meas_delay_cm;
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
if(meas_shift_index<0)
meas_shift_index = 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 // Get the delayed info and add 100 to reconstitute to a percent of
//then square it to get an area // the nominal filament diameter then square it to get an area
meas_shift_index = constrain(meas_shift_index, 0, MAX_MEASUREMENT_DELAY);
if(meas_shift_index<0) float vm = pow((measurement_delay[meas_shift_index] + 100.0) / 100.0, 2);
meas_shift_index=0; if (vm < 0.01) vm = 0.01;
else if (meas_shift_index>MAX_MEASUREMENT_DELAY) volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM] = vm;
meas_shift_index=MAX_MEASUREMENT_DELAY;
volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM] = pow((float)(100+measurement_delay[meas_shift_index])/100.0,2);
if (volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM] <0.01)
volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM]=0.01;
} }
#endif #endif //FILAMENT_SENSOR
} }
#define PGM_RD_W(x) (short)pgm_read_word(&x) #define PGM_RD_W(x) (short)pgm_read_word(&x)
@ -812,7 +810,7 @@ static void updateTemperaturesFromRawValues()
#ifdef TEMP_SENSOR_1_AS_REDUNDANT #ifdef TEMP_SENSOR_1_AS_REDUNDANT
redundant_temperature = analog2temp(redundant_temperature_raw, 1); redundant_temperature = analog2temp(redundant_temperature_raw, 1);
#endif #endif
#if defined (FILAMENT_SENSOR) && (FILWIDTH_PIN > -1) //check if a sensor is supported #if HAS_FILAMENT_SENSOR
filament_width_meas = analog2widthFil(); filament_width_meas = analog2widthFil();
#endif #endif
//Reset the watchdog after we know we have a temperature measurement. //Reset the watchdog after we know we have a temperature measurement.
@ -824,29 +822,22 @@ static void updateTemperaturesFromRawValues()
} }
// For converting raw Filament Width to milimeters
#ifdef FILAMENT_SENSOR #ifdef FILAMENT_SENSOR
float analog2widthFil() {
return current_raw_filwidth/16383.0*5.0;
//return current_raw_filwidth;
}
// For converting raw Filament Width to a ratio // Convert raw Filament Width to millimeters
int widthFil_to_size_ratio() { float analog2widthFil() {
return current_raw_filwidth / 16383.0 * 5.0;
//return current_raw_filwidth;
}
float temp; // 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;
}
temp=filament_width_meas;
if(filament_width_meas<MEASURED_LOWER_LIMIT)
temp=filament_width_nominal; //assume sensor cut out
else if (filament_width_meas>MEASURED_UPPER_LIMIT)
temp= MEASURED_UPPER_LIMIT;
return(filament_width_nominal/temp*100);
}
#endif #endif
@ -855,24 +846,24 @@ return(filament_width_nominal/temp*100);
void tp_init() void tp_init()
{ {
#if MB(RUMBA) && ((TEMP_SENSOR_0==-1)||(TEMP_SENSOR_1==-1)||(TEMP_SENSOR_2==-1)||(TEMP_SENSOR_BED==-1)) #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 //disable RUMBA JTAG in case the thermocouple extension is plugged on top of JTAG connector
MCUCR=(1<<JTD); MCUCR=(1<<JTD);
MCUCR=(1<<JTD); MCUCR=(1<<JTD);
#endif #endif
// Finish init of mult extruder arrays // Finish init of mult extruder arrays
for(int e = 0; e < EXTRUDERS; e++) { for (int e = 0; e < EXTRUDERS; e++) {
// populate with the first value // populate with the first value
maxttemp[e] = maxttemp[0]; maxttemp[e] = maxttemp[0];
#ifdef PIDTEMP #ifdef PIDTEMP
temp_iState_min[e] = 0.0; temp_iState_min[e] = 0.0;
temp_iState_max[e] = PID_INTEGRAL_DRIVE_MAX / PID_PARAM(Ki,e); temp_iState_max[e] = PID_INTEGRAL_DRIVE_MAX / PID_PARAM(Ki,e);
#endif //PIDTEMP #endif //PIDTEMP
#ifdef PIDTEMPBED #ifdef PIDTEMPBED
temp_iState_min_bed = 0.0; temp_iState_min_bed = 0.0;
temp_iState_max_bed = PID_INTEGRAL_DRIVE_MAX / bedKi; temp_iState_max_bed = PID_INTEGRAL_DRIVE_MAX / bedKi;
#endif //PIDTEMPBED #endif //PIDTEMPBED
} }
#if defined(HEATER_0_PIN) && (HEATER_0_PIN > -1) #if defined(HEATER_0_PIN) && (HEATER_0_PIN > -1)
@ -921,57 +912,35 @@ void tp_init()
#endif //HEATER_0_USES_MAX6675 #endif //HEATER_0_USES_MAX6675
#ifdef DIDR2
#define ANALOG_SELECT(pin) do{ if (pin < 8) DIDR0 |= 1 << pin; else DIDR2 |= 1 << (pin - 8); }while(0)
#else
#define ANALOG_SELECT(pin) do{ DIDR0 |= 1 << pin; }while(0)
#endif
// Set analog inputs // Set analog inputs
ADCSRA = 1<<ADEN | 1<<ADSC | 1<<ADIF | 0x07; ADCSRA = 1<<ADEN | 1<<ADSC | 1<<ADIF | 0x07;
DIDR0 = 0; DIDR0 = 0;
#ifdef DIDR2 #ifdef DIDR2
DIDR2 = 0; DIDR2 = 0;
#endif #endif
#if defined(TEMP_0_PIN) && (TEMP_0_PIN > -1) #if HAS_TEMP_0
#if TEMP_0_PIN < 8 ANALOG_SELECT(TEMP_0_PIN);
DIDR0 |= 1 << TEMP_0_PIN;
#else
DIDR2 |= 1<<(TEMP_0_PIN - 8);
#endif #endif
#if HAS_TEMP_1
ANALOG_SELECT(TEMP_1_PIN);
#endif #endif
#if defined(TEMP_1_PIN) && (TEMP_1_PIN > -1) #if HAS_TEMP_2
#if TEMP_1_PIN < 8 ANALOG_SELECT(TEMP_2_PIN);
DIDR0 |= 1<<TEMP_1_PIN;
#else
DIDR2 |= 1<<(TEMP_1_PIN - 8);
#endif #endif
#if HAS_TEMP_3
ANALOG_SELECT(TEMP_3_PIN);
#endif #endif
#if defined(TEMP_2_PIN) && (TEMP_2_PIN > -1) #if HAS_TEMP_BED
#if TEMP_2_PIN < 8 ANALOG_SELECT(TEMP_BED_PIN);
DIDR0 |= 1 << TEMP_2_PIN;
#else
DIDR2 |= 1<<(TEMP_2_PIN - 8);
#endif
#endif
#if defined(TEMP_3_PIN) && (TEMP_3_PIN > -1)
#if TEMP_3_PIN < 8
DIDR0 |= 1 << TEMP_3_PIN;
#else
DIDR2 |= 1<<(TEMP_3_PIN - 8);
#endif
#endif
#if defined(TEMP_BED_PIN) && (TEMP_BED_PIN > -1)
#if TEMP_BED_PIN < 8
DIDR0 |= 1<<TEMP_BED_PIN;
#else
DIDR2 |= 1<<(TEMP_BED_PIN - 8);
#endif
#endif
//Added for Filament Sensor
#ifdef FILAMENT_SENSOR
#if defined(FILWIDTH_PIN) && (FILWIDTH_PIN > -1)
#if FILWIDTH_PIN < 8
DIDR0 |= 1<<FILWIDTH_PIN;
#else
DIDR2 |= 1<<(FILWIDTH_PIN - 8);
#endif
#endif #endif
#if HAS_FILAMENT_SENSOR
ANALOG_SELECT(FILWIDTH_PIN);
#endif #endif
// Use timer0 for temperature measurement // Use timer0 for temperature measurement
@ -982,128 +951,89 @@ void tp_init()
// Wait for temperature measurement to settle // Wait for temperature measurement to settle
delay(250); delay(250);
#ifdef HEATER_0_MINTEMP #define TEMP_MIN_ROUTINE(NR) \
minttemp[0] = HEATER_0_MINTEMP; minttemp[NR] = HEATER_ ## NR ## _MINTEMP; \
while(analog2temp(minttemp_raw[0], 0) < HEATER_0_MINTEMP) { while(analog2temp(minttemp_raw[NR], NR) < HEATER_ ## NR ## _MINTEMP) { \
#if HEATER_0_RAW_LO_TEMP < HEATER_0_RAW_HI_TEMP if (HEATER_ ## NR ## _RAW_LO_TEMP < HEATER_ ## NR ## _RAW_HI_TEMP) \
minttemp_raw[0] += OVERSAMPLENR; minttemp_raw[NR] += OVERSAMPLENR; \
#else else \
minttemp_raw[0] -= OVERSAMPLENR; minttemp_raw[NR] -= OVERSAMPLENR; \
#endif
} }
#endif //MINTEMP #define TEMP_MAX_ROUTINE(NR) \
#ifdef HEATER_0_MAXTEMP maxttemp[NR] = HEATER_ ## NR ## _MAXTEMP; \
maxttemp[0] = HEATER_0_MAXTEMP; while(analog2temp(maxttemp_raw[NR], NR) > HEATER_ ## NR ## _MAXTEMP) { \
while(analog2temp(maxttemp_raw[0], 0) > HEATER_0_MAXTEMP) { if (HEATER_ ## NR ## _RAW_LO_TEMP < HEATER_ ## NR ## _RAW_HI_TEMP) \
#if HEATER_0_RAW_LO_TEMP < HEATER_0_RAW_HI_TEMP maxttemp_raw[NR] -= OVERSAMPLENR; \
maxttemp_raw[0] -= OVERSAMPLENR; else \
#else maxttemp_raw[NR] += OVERSAMPLENR; \
maxttemp_raw[0] += OVERSAMPLENR;
#endif
} }
#endif //MAXTEMP
#if (EXTRUDERS > 1) && defined(HEATER_1_MINTEMP) #ifdef HEATER_0_MINTEMP
minttemp[1] = HEATER_1_MINTEMP; TEMP_MIN_ROUTINE(0);
while(analog2temp(minttemp_raw[1], 1) < HEATER_1_MINTEMP) { #endif
#if HEATER_1_RAW_LO_TEMP < HEATER_1_RAW_HI_TEMP #ifdef HEATER_0_MAXTEMP
minttemp_raw[1] += OVERSAMPLENR; TEMP_MAX_ROUTINE(0);
#else #endif
minttemp_raw[1] -= OVERSAMPLENR; #if EXTRUDERS > 1
#endif #ifdef HEATER_1_MINTEMP
} TEMP_MIN_ROUTINE(1);
#endif // MINTEMP 1 #endif
#if (EXTRUDERS > 1) && defined(HEATER_1_MAXTEMP) #ifdef HEATER_1_MAXTEMP
maxttemp[1] = HEATER_1_MAXTEMP; TEMP_MAX_ROUTINE(1);
while(analog2temp(maxttemp_raw[1], 1) > HEATER_1_MAXTEMP) { #endif
#if HEATER_1_RAW_LO_TEMP < HEATER_1_RAW_HI_TEMP #if EXTRUDERS > 2
maxttemp_raw[1] -= OVERSAMPLENR; #ifdef HEATER_2_MINTEMP
#else TEMP_MIN_ROUTINE(2);
maxttemp_raw[1] += OVERSAMPLENR; #endif
#endif #ifdef HEATER_2_MAXTEMP
} TEMP_MAX_ROUTINE(2);
#endif //MAXTEMP 1 #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
#if (EXTRUDERS > 2) && defined(HEATER_2_MINTEMP) #ifdef BED_MINTEMP
minttemp[2] = HEATER_2_MINTEMP;
while(analog2temp(minttemp_raw[2], 2) < HEATER_2_MINTEMP) {
#if HEATER_2_RAW_LO_TEMP < HEATER_2_RAW_HI_TEMP
minttemp_raw[2] += OVERSAMPLENR;
#else
minttemp_raw[2] -= OVERSAMPLENR;
#endif
}
#endif //MINTEMP 2
#if (EXTRUDERS > 2) && defined(HEATER_2_MAXTEMP)
maxttemp[2] = HEATER_2_MAXTEMP;
while(analog2temp(maxttemp_raw[2], 2) > HEATER_2_MAXTEMP) {
#if HEATER_2_RAW_LO_TEMP < HEATER_2_RAW_HI_TEMP
maxttemp_raw[2] -= OVERSAMPLENR;
#else
maxttemp_raw[2] += OVERSAMPLENR;
#endif
}
#endif //MAXTEMP 2
#if (EXTRUDERS > 3) && defined(HEATER_3_MINTEMP)
minttemp[3] = HEATER_3_MINTEMP;
while(analog2temp(minttemp_raw[3], 3) < HEATER_3_MINTEMP) {
#if HEATER_3_RAW_LO_TEMP < HEATER_3_RAW_HI_TEMP
minttemp_raw[3] += OVERSAMPLENR;
#else
minttemp_raw[3] -= OVERSAMPLENR;
#endif
}
#endif //MINTEMP 3
#if (EXTRUDERS > 3) && defined(HEATER_3_MAXTEMP)
maxttemp[3] = HEATER_3_MAXTEMP;
while(analog2temp(maxttemp_raw[3], 3) > HEATER_3_MAXTEMP) {
#if HEATER_3_RAW_LO_TEMP < HEATER_3_RAW_HI_TEMP
maxttemp_raw[3] -= OVERSAMPLENR;
#else
maxttemp_raw[3] += OVERSAMPLENR;
#endif
}
#endif // MAXTEMP 3
#ifdef BED_MINTEMP
/* No bed MINTEMP error implemented?!? */ /* /* No bed MINTEMP error implemented?!? */ /*
while(analog2tempBed(bed_minttemp_raw) < BED_MINTEMP) { while(analog2tempBed(bed_minttemp_raw) < BED_MINTEMP) {
#if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP #if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP
bed_minttemp_raw += OVERSAMPLENR; bed_minttemp_raw += OVERSAMPLENR;
#else #else
bed_minttemp_raw -= OVERSAMPLENR; bed_minttemp_raw -= OVERSAMPLENR;
#endif #endif
} }
*/ */
#endif //BED_MINTEMP #endif //BED_MINTEMP
#ifdef BED_MAXTEMP #ifdef BED_MAXTEMP
while(analog2tempBed(bed_maxttemp_raw) > BED_MAXTEMP) { while(analog2tempBed(bed_maxttemp_raw) > BED_MAXTEMP) {
#if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP #if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP
bed_maxttemp_raw -= OVERSAMPLENR; bed_maxttemp_raw -= OVERSAMPLENR;
#else #else
bed_maxttemp_raw += OVERSAMPLENR; bed_maxttemp_raw += OVERSAMPLENR;
#endif #endif
} }
#endif //BED_MAXTEMP #endif //BED_MAXTEMP
} }
void setWatch() void setWatch() {
{ #ifdef WATCH_TEMP_PERIOD
#ifdef WATCH_TEMP_PERIOD unsigned long ms = millis();
for (int e = 0; e < EXTRUDERS; e++) for (int e = 0; e < EXTRUDERS; e++) {
{ if (degHotend(e) < degTargetHotend(e) - (WATCH_TEMP_INCREASE * 2)) {
if(degHotend(e) < degTargetHotend(e) - (WATCH_TEMP_INCREASE * 2))
{
watch_start_temp[e] = degHotend(e); watch_start_temp[e] = degHotend(e);
watchmillis[e] = millis(); watchmillis[e] = ms;
} }
} }
#endif #endif
} }
#if defined (THERMAL_RUNAWAY_PROTECTION_PERIOD) && THERMAL_RUNAWAY_PROTECTION_PERIOD > 0 #if defined(THERMAL_RUNAWAY_PROTECTION_PERIOD) && THERMAL_RUNAWAY_PROTECTION_PERIOD > 0
void thermal_runaway_protection(int *state, unsigned long *timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc) void thermal_runaway_protection(int *state, unsigned long *timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc)
{ {
/* /*
@ -1135,11 +1065,13 @@ void thermal_runaway_protection(int *state, unsigned long *timer, float temperat
if (temperature >= target_temperature) *state = 2; if (temperature >= target_temperature) *state = 2;
break; break;
case 2: // "Temperature Stable" state case 2: // "Temperature Stable" state
{
unsigned long ms = millis();
if (temperature >= (target_temperature - hysteresis_degc)) if (temperature >= (target_temperature - hysteresis_degc))
{ {
*timer = millis(); *timer = ms;
} }
else if ( (millis() - *timer) > ((unsigned long) period_seconds) * 1000) else if ( (ms - *timer) > ((unsigned long) period_seconds) * 1000)
{ {
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Thermal Runaway, system stopped! Heater_ID: "); SERIAL_ERRORLNPGM("Thermal Runaway, system stopped! Heater_ID: ");
@ -1160,54 +1092,45 @@ void thermal_runaway_protection(int *state, unsigned long *timer, float temperat
lcd_update(); lcd_update();
} }
} }
break; } break;
} }
} }
#endif #endif //THERMAL_RUNAWAY_PROTECTION_PERIOD
void disable_heater()
{ void disable_heater() {
for(int i=0;i<EXTRUDERS;i++) for (int i=0; i<EXTRUDERS; i++) setTargetHotend(0, i);
setTargetHotend(0,i);
setTargetBed(0); setTargetBed(0);
#if defined(TEMP_0_PIN) && TEMP_0_PIN > -1
target_temperature[0]=0; #if HAS_TEMP_0
soft_pwm[0]=0; target_temperature[0] = 0;
#if defined(HEATER_0_PIN) && HEATER_0_PIN > -1 soft_pwm[0] = 0;
WRITE(HEATER_0_PIN,LOW); WRITE_HEATER_0P(LOW); // If HEATERS_PARALLEL should apply, change to WRITE_HEATER_0
#endif
#endif #endif
#if defined(TEMP_1_PIN) && TEMP_1_PIN > -1 && EXTRUDERS > 1 #if EXTRUDERS > 1 && HAS_TEMP_1
target_temperature[1]=0; target_temperature[1] = 0;
soft_pwm[1]=0; soft_pwm[1] = 0;
#if defined(HEATER_1_PIN) && HEATER_1_PIN > -1 WRITE_HEATER_1(LOW);
WRITE(HEATER_1_PIN,LOW);
#endif
#endif #endif
#if defined(TEMP_2_PIN) && TEMP_2_PIN > -1 && EXTRUDERS > 2 #if EXTRUDERS > 2 && HAS_TEMP_2
target_temperature[2]=0; target_temperature[2] = 0;
soft_pwm[2]=0; soft_pwm[2] = 0;
#if defined(HEATER_2_PIN) && HEATER_2_PIN > -1 WRITE_HEATER_2(LOW);
WRITE(HEATER_2_PIN,LOW);
#endif
#endif #endif
#if defined(TEMP_3_PIN) && TEMP_3_PIN > -1 && EXTRUDERS > 3 #if EXTRUDERS > 3 && HAS_TEMP_3
target_temperature[3]=0; target_temperature[3] = 0;
soft_pwm[3]=0; soft_pwm[3] = 0;
#if defined(HEATER_3_PIN) && HEATER_3_PIN > -1 WRITE_HEATER_3(LOW);
WRITE(HEATER_3_PIN,LOW);
#endif
#endif #endif
#if HAS_TEMP_BED
#if defined(TEMP_BED_PIN) && TEMP_BED_PIN > -1 target_temperature_bed = 0;
target_temperature_bed=0; soft_pwm_bed = 0;
soft_pwm_bed=0;
#if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1 #if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
WRITE(HEATER_BED_PIN,LOW); WRITE_HEATER_BED(LOW);
#endif #endif
#endif #endif
} }
@ -1239,10 +1162,10 @@ void min_temp_error(uint8_t e) {
} }
void bed_max_temp_error(void) { void bed_max_temp_error(void) {
#if HEATER_BED_PIN > -1 #if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
WRITE(HEATER_BED_PIN, 0); WRITE_HEATER_BED(0);
#endif #endif
if(IsStopped() == false) { if (IsStopped() == false) {
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Temperature heated bed switched off. MAXTEMP triggered !!"); SERIAL_ERRORLNPGM("Temperature heated bed switched off. MAXTEMP triggered !!");
LCD_ALERTMESSAGEPGM("Err: MAXTEMP BED"); LCD_ALERTMESSAGEPGM("Err: MAXTEMP BED");
@ -1253,16 +1176,17 @@ void bed_max_temp_error(void) {
} }
#ifdef HEATER_0_USES_MAX6675 #ifdef HEATER_0_USES_MAX6675
#define MAX6675_HEAT_INTERVAL 250 #define MAX6675_HEAT_INTERVAL 250
long max6675_previous_millis = MAX6675_HEAT_INTERVAL; long max6675_previous_millis = MAX6675_HEAT_INTERVAL;
int max6675_temp = 2000; int max6675_temp = 2000;
static int read_max6675() static int read_max6675() {
{
if (millis() - max6675_previous_millis < MAX6675_HEAT_INTERVAL) unsigned long ms = millis();
if (ms < max6675_previous_millis + MAX6675_HEAT_INTERVAL)
return max6675_temp; return max6675_temp;
max6675_previous_millis = millis(); max6675_previous_millis = ms;
max6675_temp = 0; max6675_temp = 0;
#ifdef PRR #ifdef PRR
@ -1294,25 +1218,39 @@ static int read_max6675()
// disable TT_MAX6675 // disable TT_MAX6675
WRITE(MAX6675_SS, 1); WRITE(MAX6675_SS, 1);
if (max6675_temp & 4) if (max6675_temp & 4) {
{
// thermocouple open // thermocouple open
max6675_temp = 4000; max6675_temp = 4000;
} }
else else {
{
max6675_temp = max6675_temp >> 3; max6675_temp = max6675_temp >> 3;
} }
return max6675_temp; return max6675_temp;
} }
#endif //HEATER_0_USES_MAX6675 #endif //HEATER_0_USES_MAX6675
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
};
//
// Timer 0 is shared with millies // Timer 0 is shared with millies
ISR(TIMER0_COMPB_vect) //
{ ISR(TIMER0_COMPB_vect) {
//these variables are only accesible from the ISR, but static, so they don't lose their value //these variables are only accesible from the ISR, but static, so they don't lose their value
static unsigned char temp_count = 0; static unsigned char temp_count = 0;
static unsigned long raw_temp_0_value = 0; static unsigned long raw_temp_0_value = 0;
@ -1320,340 +1258,172 @@ ISR(TIMER0_COMPB_vect)
static unsigned long raw_temp_2_value = 0; static unsigned long raw_temp_2_value = 0;
static unsigned long raw_temp_3_value = 0; static unsigned long raw_temp_3_value = 0;
static unsigned long raw_temp_bed_value = 0; static unsigned long raw_temp_bed_value = 0;
static unsigned char temp_state = 12; static TempState temp_state = StartupDelay;
static unsigned char pwm_count = (1 << SOFT_PWM_SCALE); static unsigned char pwm_count = (1 << SOFT_PWM_SCALE);
static unsigned char soft_pwm_0;
#ifdef SLOW_PWM_HEATERS // Static members for each heater
#ifdef SLOW_PWM_HEATERS
static unsigned char slow_pwm_count = 0; static unsigned char slow_pwm_count = 0;
static unsigned char state_heater_0 = 0; #define ISR_STATICS(n) \
static unsigned char state_timer_heater_0 = 0; static unsigned char soft_pwm_ ## n; \
#endif 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
#endif
#if (EXTRUDERS > 1) || defined(HEATERS_PARALLEL) // Statics per heater
static unsigned char soft_pwm_1; ISR_STATICS(0);
#ifdef SLOW_PWM_HEATERS #if (EXTRUDERS > 1) || defined(HEATERS_PARALLEL)
static unsigned char state_heater_1 = 0; ISR_STATICS(1);
static unsigned char state_timer_heater_1 = 0; #if EXTRUDERS > 2
#endif ISR_STATICS(2);
#endif #if EXTRUDERS > 3
#if EXTRUDERS > 2 ISR_STATICS(3);
static unsigned char soft_pwm_2; #endif
#ifdef SLOW_PWM_HEATERS #endif
static unsigned char state_heater_2 = 0; #endif
static unsigned char state_timer_heater_2 = 0; #if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
#endif ISR_STATICS(BED);
#endif #endif
#if EXTRUDERS > 3
static unsigned char soft_pwm_3;
#ifdef SLOW_PWM_HEATERS
static unsigned char state_heater_3 = 0;
static unsigned char state_timer_heater_3 = 0;
#endif
#endif
#if HEATER_BED_PIN > -1 #if HAS_FILAMENT_SENSOR
static unsigned char soft_pwm_b; static unsigned long raw_filwidth_value = 0;
#ifdef SLOW_PWM_HEATERS #endif
static unsigned char state_heater_b = 0;
static unsigned char state_timer_heater_b = 0;
#endif
#endif
#if defined(FILWIDTH_PIN) &&(FILWIDTH_PIN > -1) #ifndef SLOW_PWM_HEATERS
static unsigned long raw_filwidth_value = 0; //added for filament width sensor /**
#endif
#ifndef SLOW_PWM_HEATERS
/*
* standard PWM modulation * standard PWM modulation
*/ */
if(pwm_count == 0){ if (pwm_count == 0) {
soft_pwm_0 = soft_pwm[0]; soft_pwm_0 = soft_pwm[0];
if(soft_pwm_0 > 0) { if (soft_pwm_0 > 0) {
WRITE(HEATER_0_PIN,1); WRITE_HEATER_0(1);
#ifdef HEATERS_PARALLEL }
WRITE(HEATER_1_PIN,1); else WRITE_HEATER_0P(0); // If HEATERS_PARALLEL should apply, change to WRITE_HEATER_0
#endif
} else WRITE(HEATER_0_PIN,0);
#if EXTRUDERS > 1 #if EXTRUDERS > 1
soft_pwm_1 = soft_pwm[1]; soft_pwm_1 = soft_pwm[1];
if(soft_pwm_1 > 0) WRITE(HEATER_1_PIN,1); else WRITE(HEATER_1_PIN,0); WRITE_HEATER_1(soft_pwm_1 > 0 ? 1 : 0);
#endif #if EXTRUDERS > 2
#if EXTRUDERS > 2
soft_pwm_2 = soft_pwm[2]; soft_pwm_2 = soft_pwm[2];
if(soft_pwm_2 > 0) WRITE(HEATER_2_PIN,1); else WRITE(HEATER_2_PIN,0); WRITE_HEATER_2(soft_pwm_2 > 0 ? 1 : 0);
#endif #if EXTRUDERS > 3
#if EXTRUDERS > 3
soft_pwm_3 = soft_pwm[3]; soft_pwm_3 = soft_pwm[3];
if(soft_pwm_3 > 0) WRITE(HEATER_3_PIN,1); else WRITE(HEATER_3_PIN,0); WRITE_HEATER_3(soft_pwm_3 > 0 ? 1 : 0);
#endif #endif
#endif
#endif
#if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
#if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1 soft_pwm_BED = soft_pwm_bed;
soft_pwm_b = soft_pwm_bed; WRITE_HEATER_BED(soft_pwm_BED > 0 ? 1 : 0);
if(soft_pwm_b > 0) WRITE(HEATER_BED_PIN,1); else WRITE(HEATER_BED_PIN,0); #endif
#endif #ifdef FAN_SOFT_PWM
#ifdef FAN_SOFT_PWM
soft_pwm_fan = fanSpeedSoftPwm / 2; soft_pwm_fan = fanSpeedSoftPwm / 2;
if(soft_pwm_fan > 0) WRITE(FAN_PIN,1); else WRITE(FAN_PIN,0); WRITE(FAN_PIN, soft_pwm_fan > 0 ? 1 : 0);
#endif #endif
}
if(soft_pwm_0 < pwm_count) {
WRITE(HEATER_0_PIN,0);
#ifdef HEATERS_PARALLEL
WRITE(HEATER_1_PIN,0);
#endif
} }
#if EXTRUDERS > 1 if (soft_pwm_0 < pwm_count) { WRITE_HEATER_0(0); }
if(soft_pwm_1 < pwm_count) WRITE(HEATER_1_PIN,0); #if EXTRUDERS > 1
#endif if (soft_pwm_1 < pwm_count) WRITE_HEATER_1(0);
#if EXTRUDERS > 2 #if EXTRUDERS > 2
if(soft_pwm_2 < pwm_count) WRITE(HEATER_2_PIN,0); if (soft_pwm_2 < pwm_count) WRITE_HEATER_2(0);
#endif #if EXTRUDERS > 3
#if EXTRUDERS > 3 if (soft_pwm_3 < pwm_count) WRITE_HEATER_3(0);
if(soft_pwm_3 < pwm_count) WRITE(HEATER_3_PIN,0); #endif
#endif #endif
#endif
#if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1 #if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
if(soft_pwm_b < pwm_count) WRITE(HEATER_BED_PIN,0); if (soft_pwm_BED < pwm_count) WRITE_HEATER_BED(0);
#endif #endif
#ifdef FAN_SOFT_PWM
if(soft_pwm_fan < pwm_count) WRITE(FAN_PIN,0); #ifdef FAN_SOFT_PWM
#endif if (soft_pwm_fan < pwm_count) WRITE(FAN_PIN, 0);
#endif
pwm_count += (1 << SOFT_PWM_SCALE); pwm_count += (1 << SOFT_PWM_SCALE);
pwm_count &= 0x7f; pwm_count &= 0x7f;
#else //ifndef SLOW_PWM_HEATERS #else // SLOW_PWM_HEATERS
/* /*
* SLOW PWM HEATERS * SLOW PWM HEATERS
* *
* for heaters drived by relay * for heaters drived by relay
*/ */
#ifndef MIN_STATE_TIME #ifndef MIN_STATE_TIME
#define MIN_STATE_TIME 16 // MIN_STATE_TIME * 65.5 = time in milliseconds #define MIN_STATE_TIME 16 // MIN_STATE_TIME * 65.5 = time in milliseconds
#endif #endif
// 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); \
} \
}
#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); \
} \
}
if (slow_pwm_count == 0) { if (slow_pwm_count == 0) {
// EXTRUDER 0
soft_pwm_0 = soft_pwm[0];
if (soft_pwm_0 > 0) {
// turn ON heather only if the minimum time is up
if (state_timer_heater_0 == 0) {
// if change state set timer
if (state_heater_0 == 0) {
state_timer_heater_0 = MIN_STATE_TIME;
}
state_heater_0 = 1;
WRITE(HEATER_0_PIN, 1);
#ifdef HEATERS_PARALLEL
WRITE(HEATER_1_PIN, 1);
#endif
}
} else {
// turn OFF heather only if the minimum time is up
if (state_timer_heater_0 == 0) {
// if change state set timer
if (state_heater_0 == 1) {
state_timer_heater_0 = MIN_STATE_TIME;
}
state_heater_0 = 0;
WRITE(HEATER_0_PIN, 0);
#ifdef HEATERS_PARALLEL
WRITE(HEATER_1_PIN, 0);
#endif
}
}
#if EXTRUDERS > 1 SLOW_PWM_ROUTINE(0); // EXTRUDER 0
// EXTRUDER 1 #if EXTRUDERS > 1
soft_pwm_1 = soft_pwm[1]; SLOW_PWM_ROUTINE(1); // EXTRUDER 1
if (soft_pwm_1 > 0) { #if EXTRUDERS > 2
// turn ON heather only if the minimum time is up SLOW_PWM_ROUTINE(2); // EXTRUDER 2
if (state_timer_heater_1 == 0) { #if EXTRUDERS > 3
// if change state set timer SLOW_PWM_ROUTINE(3); // EXTRUDER 3
if (state_heater_1 == 0) { #endif
state_timer_heater_1 = MIN_STATE_TIME; #endif
} #endif
state_heater_1 = 1; #if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
WRITE(HEATER_1_PIN, 1); _SLOW_PWM_ROUTINE(BED, soft_pwm_bed); // BED
} #endif
} else {
// turn OFF heather only if the minimum time is up
if (state_timer_heater_1 == 0) {
// if change state set timer
if (state_heater_1 == 1) {
state_timer_heater_1 = MIN_STATE_TIME;
}
state_heater_1 = 0;
WRITE(HEATER_1_PIN, 0);
}
}
#endif
#if EXTRUDERS > 2 } // slow_pwm_count == 0
// EXTRUDER 2
soft_pwm_2 = soft_pwm[2];
if (soft_pwm_2 > 0) {
// turn ON heather only if the minimum time is up
if (state_timer_heater_2 == 0) {
// if change state set timer
if (state_heater_2 == 0) {
state_timer_heater_2 = MIN_STATE_TIME;
}
state_heater_2 = 1;
WRITE(HEATER_2_PIN, 1);
}
} else {
// turn OFF heather only if the minimum time is up
if (state_timer_heater_2 == 0) {
// if change state set timer
if (state_heater_2 == 1) {
state_timer_heater_2 = MIN_STATE_TIME;
}
state_heater_2 = 0;
WRITE(HEATER_2_PIN, 0);
}
}
#endif
#if EXTRUDERS > 3 PWM_OFF_ROUTINE(0); // EXTRUDER 0
// EXTRUDER 3 #if EXTRUDERS > 1
soft_pwm_3 = soft_pwm[3]; PWM_OFF_ROUTINE(1); // EXTRUDER 1
if (soft_pwm_3 > 0) { #if EXTRUDERS > 2
// turn ON heather only if the minimum time is up PWM_OFF_ROUTINE(2); // EXTRUDER 2
if (state_timer_heater_3 == 0) { #if EXTRUDERS > 3
// if change state set timer PWM_OFF_ROUTINE(3); // EXTRUDER 3
if (state_heater_3 == 0) { #endif
state_timer_heater_3 = MIN_STATE_TIME; #endif
} #endif
state_heater_3 = 1; #if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
WRITE(HEATER_3_PIN, 1); PWM_OFF_ROUTINE(BED); // BED
} #endif
} else {
// turn OFF heather only if the minimum time is up
if (state_timer_heater_3 == 0) {
// if change state set timer
if (state_heater_3 == 1) {
state_timer_heater_3 = MIN_STATE_TIME;
}
state_heater_3 = 0;
WRITE(HEATER_3_PIN, 0);
}
}
#endif
#if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1 #ifdef FAN_SOFT_PWM
// BED if (pwm_count == 0) {
soft_pwm_b = soft_pwm_bed;
if (soft_pwm_b > 0) {
// turn ON heather only if the minimum time is up
if (state_timer_heater_b == 0) {
// if change state set timer
if (state_heater_b == 0) {
state_timer_heater_b = MIN_STATE_TIME;
}
state_heater_b = 1;
WRITE(HEATER_BED_PIN, 1);
}
} else {
// turn OFF heather only if the minimum time is up
if (state_timer_heater_b == 0) {
// if change state set timer
if (state_heater_b == 1) {
state_timer_heater_b = MIN_STATE_TIME;
}
state_heater_b = 0;
WRITE(HEATER_BED_PIN, 0);
}
}
#endif
} // if (slow_pwm_count == 0)
// EXTRUDER 0
if (soft_pwm_0 < slow_pwm_count) {
// turn OFF heather only if the minimum time is up
if (state_timer_heater_0 == 0) {
// if change state set timer
if (state_heater_0 == 1) {
state_timer_heater_0 = MIN_STATE_TIME;
}
state_heater_0 = 0;
WRITE(HEATER_0_PIN, 0);
#ifdef HEATERS_PARALLEL
WRITE(HEATER_1_PIN, 0);
#endif
}
}
#if EXTRUDERS > 1
// EXTRUDER 1
if (soft_pwm_1 < slow_pwm_count) {
// turn OFF heather only if the minimum time is up
if (state_timer_heater_1 == 0) {
// if change state set timer
if (state_heater_1 == 1) {
state_timer_heater_1 = MIN_STATE_TIME;
}
state_heater_1 = 0;
WRITE(HEATER_1_PIN, 0);
}
}
#endif
#if EXTRUDERS > 2
// EXTRUDER 2
if (soft_pwm_2 < slow_pwm_count) {
// turn OFF heather only if the minimum time is up
if (state_timer_heater_2 == 0) {
// if change state set timer
if (state_heater_2 == 1) {
state_timer_heater_2 = MIN_STATE_TIME;
}
state_heater_2 = 0;
WRITE(HEATER_2_PIN, 0);
}
}
#endif
#if EXTRUDERS > 3
// EXTRUDER 3
if (soft_pwm_3 < slow_pwm_count) {
// turn OFF heather only if the minimum time is up
if (state_timer_heater_3 == 0) {
// if change state set timer
if (state_heater_3 == 1) {
state_timer_heater_3 = MIN_STATE_TIME;
}
state_heater_3 = 0;
WRITE(HEATER_3_PIN, 0);
}
}
#endif
#if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
// BED
if (soft_pwm_b < slow_pwm_count) {
// turn OFF heather only if the minimum time is up
if (state_timer_heater_b == 0) {
// if change state set timer
if (state_heater_b == 1) {
state_timer_heater_b = MIN_STATE_TIME;
}
state_heater_b = 0;
WRITE(HEATER_BED_PIN, 0);
}
}
#endif
#ifdef FAN_SOFT_PWM
if (pwm_count == 0){
soft_pwm_fan = fanSpeedSoftPwm / 2; soft_pwm_fan = fanSpeedSoftPwm / 2;
if (soft_pwm_fan > 0) WRITE(FAN_PIN,1); else WRITE(FAN_PIN,0); WRITE(FAN_PIN, soft_pwm_fan > 0 ? 1 : 0);
} }
if (soft_pwm_fan < pwm_count) WRITE(FAN_PIN,0); if (soft_pwm_fan < pwm_count) WRITE(FAN_PIN, 0);
#endif #endif //FAN_SOFT_PWM
pwm_count += (1 << SOFT_PWM_SCALE); pwm_count += (1 << SOFT_PWM_SCALE);
pwm_count &= 0x7f; pwm_count &= 0x7f;
@ -1663,199 +1433,149 @@ ISR(TIMER0_COMPB_vect)
slow_pwm_count++; slow_pwm_count++;
slow_pwm_count &= 0x7f; slow_pwm_count &= 0x7f;
// Extruder 0 // EXTRUDER 0
if (state_timer_heater_0 > 0) { if (state_timer_heater_0 > 0) state_timer_heater_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
#if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1 // BED
if (state_timer_heater_BED > 0) state_timer_heater_BED--;
#endif
} // (pwm_count % 64) == 0
#if EXTRUDERS > 1 #endif // SLOW_PWM_HEATERS
// Extruder 1
if (state_timer_heater_1 > 0)
state_timer_heater_1--;
#endif
#if EXTRUDERS > 2 #define SET_ADMUX_ADCSRA(pin) ADMUX = (1 << REFS0) | (pin & 0x07); ADCSRA |= 1<<ADSC
// Extruder 2 #ifdef MUX5
if (state_timer_heater_2 > 0) #define SET_ADCSRB(pin) if (pin > 7) ADCSRB = 1 << MUX5; else ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
state_timer_heater_2--; #else
#endif #define SET_ADCSRB(pin) ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
#endif
#if EXTRUDERS > 3
// Extruder 3
if (state_timer_heater_3 > 0)
state_timer_heater_3--;
#endif
#if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
// Bed
if (state_timer_heater_b > 0)
state_timer_heater_b--;
#endif
} //if ((pwm_count % 64) == 0) {
#endif //ifndef SLOW_PWM_HEATERS
switch(temp_state) { switch(temp_state) {
case 0: // Prepare TEMP_0 case PrepareTemp_0:
#if defined(TEMP_0_PIN) && (TEMP_0_PIN > -1) #if HAS_TEMP_0
#if TEMP_0_PIN > 7 SET_ADCSRB(TEMP_0_PIN);
ADCSRB = 1<<MUX5;
#else
ADCSRB = 0;
#endif
ADMUX = ((1 << REFS0) | (TEMP_0_PIN & 0x07));
ADCSRA |= 1<<ADSC; // Start conversion
#endif #endif
lcd_buttons_update(); lcd_buttons_update();
temp_state = 1; temp_state = MeasureTemp_0;
break; break;
case 1: // Measure TEMP_0 case MeasureTemp_0:
#if defined(TEMP_0_PIN) && (TEMP_0_PIN > -1) #if HAS_TEMP_0
raw_temp_0_value += ADC; raw_temp_0_value += ADC;
#endif #endif
temp_state = 2; temp_state = PrepareTemp_BED;
break; break;
case 2: // Prepare TEMP_BED case PrepareTemp_BED:
#if defined(TEMP_BED_PIN) && (TEMP_BED_PIN > -1) #if HAS_TEMP_BED
#if TEMP_BED_PIN > 7 SET_ADCSRB(TEMP_BED_PIN);
ADCSRB = 1<<MUX5;
#else
ADCSRB = 0;
#endif
ADMUX = ((1 << REFS0) | (TEMP_BED_PIN & 0x07));
ADCSRA |= 1<<ADSC; // Start conversion
#endif #endif
lcd_buttons_update(); lcd_buttons_update();
temp_state = 3; temp_state = MeasureTemp_BED;
break; break;
case 3: // Measure TEMP_BED case MeasureTemp_BED:
#if defined(TEMP_BED_PIN) && (TEMP_BED_PIN > -1) #if HAS_TEMP_BED
raw_temp_bed_value += ADC; raw_temp_bed_value += ADC;
#endif #endif
temp_state = 4; temp_state = PrepareTemp_1;
break; break;
case 4: // Prepare TEMP_1 case PrepareTemp_1:
#if defined(TEMP_1_PIN) && (TEMP_1_PIN > -1) #if HAS_TEMP_1
#if TEMP_1_PIN > 7 SET_ADCSRB(TEMP_1_PIN);
ADCSRB = 1<<MUX5;
#else
ADCSRB = 0;
#endif
ADMUX = ((1 << REFS0) | (TEMP_1_PIN & 0x07));
ADCSRA |= 1<<ADSC; // Start conversion
#endif #endif
lcd_buttons_update(); lcd_buttons_update();
temp_state = 5; temp_state = MeasureTemp_1;
break; break;
case 5: // Measure TEMP_1 case MeasureTemp_1:
#if defined(TEMP_1_PIN) && (TEMP_1_PIN > -1) #if HAS_TEMP_1
raw_temp_1_value += ADC; raw_temp_1_value += ADC;
#endif #endif
temp_state = 6; temp_state = PrepareTemp_2;
break; break;
case 6: // Prepare TEMP_2 case PrepareTemp_2:
#if defined(TEMP_2_PIN) && (TEMP_2_PIN > -1) #if HAS_TEMP_2
#if TEMP_2_PIN > 7 SET_ADCSRB(TEMP_2_PIN);
ADCSRB = 1<<MUX5;
#else
ADCSRB = 0;
#endif
ADMUX = ((1 << REFS0) | (TEMP_2_PIN & 0x07));
ADCSRA |= 1<<ADSC; // Start conversion
#endif #endif
lcd_buttons_update(); lcd_buttons_update();
temp_state = 7; temp_state = MeasureTemp_2;
break; break;
case 7: // Measure TEMP_2 case MeasureTemp_2:
#if defined(TEMP_2_PIN) && (TEMP_2_PIN > -1) #if HAS_TEMP_2
raw_temp_2_value += ADC; raw_temp_2_value += ADC;
#endif #endif
temp_state = 8; temp_state = PrepareTemp_3;
break; break;
case 8: // Prepare TEMP_3 case PrepareTemp_3:
#if defined(TEMP_3_PIN) && (TEMP_3_PIN > -1) #if HAS_TEMP_3
#if TEMP_3_PIN > 7 SET_ADCSRB(TEMP_3_PIN);
ADCSRB = 1<<MUX5;
#else
ADCSRB = 0;
#endif
ADMUX = ((1 << REFS0) | (TEMP_3_PIN & 0x07));
ADCSRA |= 1<<ADSC; // Start conversion
#endif #endif
lcd_buttons_update(); lcd_buttons_update();
temp_state = 9; temp_state = MeasureTemp_3;
break; break;
case 9: // Measure TEMP_3 case MeasureTemp_3:
#if defined(TEMP_3_PIN) && (TEMP_3_PIN > -1) #if HAS_TEMP_3
raw_temp_3_value += ADC; raw_temp_3_value += ADC;
#endif #endif
temp_state = 10; //change so that Filament Width is also measured temp_state = Prepare_FILWIDTH;
break; break;
case 10: //Prepare FILWIDTH case Prepare_FILWIDTH:
#if defined(FILWIDTH_PIN) && (FILWIDTH_PIN> -1) #if HAS_FILAMENT_SENSOR
#if FILWIDTH_PIN>7 SET_ADCSRB(FILWIDTH_PIN);
ADCSRB = 1<<MUX5;
#else
ADCSRB = 0;
#endif
ADMUX = ((1 << REFS0) | (FILWIDTH_PIN & 0x07));
ADCSRA |= 1<<ADSC; // Start conversion
#endif #endif
lcd_buttons_update(); lcd_buttons_update();
temp_state = 11; temp_state = Measure_FILWIDTH;
break; break;
case 11: //Measure FILWIDTH case Measure_FILWIDTH:
#if defined(FILWIDTH_PIN) &&(FILWIDTH_PIN > -1) #if HAS_FILAMENT_SENSOR
//raw_filwidth_value += ADC; //remove to use an IIR filter approach // 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. 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= raw_filwidth_value-(raw_filwidth_value>>7); //multipliy raw_filwidth_value by 127/128 raw_filwidth_value += ((unsigned long)ADC<<7); //add new ADC reading
raw_filwidth_value= raw_filwidth_value + ((unsigned long)ADC<<7); //add new ADC reading
} }
#endif #endif
temp_state = 0; temp_state = PrepareTemp_0;
temp_count++; temp_count++;
break; break;
case StartupDelay:
temp_state = PrepareTemp_0;
case 12: //Startup, delay initial temp reading a tiny bit so the hardware can settle.
temp_state = 0;
break; break;
// default:
// SERIAL_ERROR_START;
// SERIAL_ERRORLNPGM("Temp measurement error!");
// break;
}
if(temp_count >= OVERSAMPLENR) // 10 * 16 * 1/(16000000/64/256) = 164ms. // default:
{ // SERIAL_ERROR_START;
if (!temp_meas_ready) //Only update the raw values if they have been read. Else we could be updating them during reading. // SERIAL_ERRORLNPGM("Temp measurement error!");
{ // break;
#ifndef HEATER_0_USES_MAX6675 } // switch(temp_state)
if (temp_count >= OVERSAMPLENR) { // 10 * 16 * 1/(16000000/64/256) = 164ms.
if (!temp_meas_ready) { //Only update the raw values if they have been read. Else we could be updating them during reading.
#ifndef HEATER_0_USES_MAX6675
current_temperature_raw[0] = raw_temp_0_value; current_temperature_raw[0] = raw_temp_0_value;
#endif #endif
#if EXTRUDERS > 1 #if EXTRUDERS > 1
current_temperature_raw[1] = raw_temp_1_value; current_temperature_raw[1] = raw_temp_1_value;
#endif #if EXTRUDERS > 2
#ifdef TEMP_SENSOR_1_AS_REDUNDANT
redundant_temperature_raw = raw_temp_1_value;
#endif
#if EXTRUDERS > 2
current_temperature_raw[2] = raw_temp_2_value; current_temperature_raw[2] = raw_temp_2_value;
#endif #if EXTRUDERS > 3
#if EXTRUDERS > 3
current_temperature_raw[3] = raw_temp_3_value; current_temperature_raw[3] = raw_temp_3_value;
#endif #endif
#endif
#endif
#ifdef TEMP_SENSOR_1_AS_REDUNDANT
redundant_temperature_raw = raw_temp_1_value;
#endif
current_temperature_bed_raw = raw_temp_bed_value; current_temperature_bed_raw = raw_temp_bed_value;
} } //!temp_meas_ready
//Add similar code for Filament Sensor - can be read any time since IIR filtering is used
#if defined(FILWIDTH_PIN) &&(FILWIDTH_PIN > -1)
current_raw_filwidth = raw_filwidth_value>>10; //need to divide to get to 0-16384 range since we used 1/128 IIR filter approach
#endif
// 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
temp_meas_ready = true; temp_meas_ready = true;
temp_count = 0; temp_count = 0;
@ -1865,131 +1585,47 @@ ISR(TIMER0_COMPB_vect)
raw_temp_3_value = 0; raw_temp_3_value = 0;
raw_temp_bed_value = 0; raw_temp_bed_value = 0;
#if HEATER_0_RAW_LO_TEMP > HEATER_0_RAW_HI_TEMP #if HEATER_0_RAW_LO_TEMP > HEATER_0_RAW_HI_TEMP
if(current_temperature_raw[0] <= maxttemp_raw[0]) { #define MAXTEST <=
#else #define MINTEST >=
if(current_temperature_raw[0] >= maxttemp_raw[0]) { #else
#endif #define MAXTEST >=
#ifndef HEATER_0_USES_MAX6675 #define MINTEST <=
max_temp_error(0); #endif
#endif
}
#if HEATER_0_RAW_LO_TEMP > HEATER_0_RAW_HI_TEMP
if(current_temperature_raw[0] >= minttemp_raw[0]) {
#else
if(current_temperature_raw[0] <= minttemp_raw[0]) {
#endif
#ifndef HEATER_0_USES_MAX6675
min_temp_error(0);
#endif
}
for (int i=0; i<EXTRUDERS; i++) {
#if EXTRUDERS > 1 if (current_temperature_raw[i] MAXTEST maxttemp_raw[i]) max_temp_error(i);
#if HEATER_1_RAW_LO_TEMP > HEATER_1_RAW_HI_TEMP else if (current_temperature_raw[i] MINTEST minttemp_raw[i]) min_temp_error(i);
if(current_temperature_raw[1] <= maxttemp_raw[1]) {
#else
if(current_temperature_raw[1] >= maxttemp_raw[1]) {
#endif
max_temp_error(1);
} }
#if HEATER_1_RAW_LO_TEMP > HEATER_1_RAW_HI_TEMP
if(current_temperature_raw[1] >= minttemp_raw[1]) {
#else
if(current_temperature_raw[1] <= minttemp_raw[1]) {
#endif
min_temp_error(1);
}
#endif
#if EXTRUDERS > 2
#if HEATER_2_RAW_LO_TEMP > HEATER_2_RAW_HI_TEMP
if(current_temperature_raw[2] <= maxttemp_raw[2]) {
#else
if(current_temperature_raw[2] >= maxttemp_raw[2]) {
#endif
max_temp_error(2);
}
#if HEATER_2_RAW_LO_TEMP > HEATER_2_RAW_HI_TEMP
if(current_temperature_raw[2] >= minttemp_raw[2]) {
#else
if(current_temperature_raw[2] <= minttemp_raw[2]) {
#endif
min_temp_error(2);
}
#endif
#if EXTRUDERS > 3
#if HEATER_3_RAW_LO_TEMP > HEATER_3_RAW_HI_TEMP
if(current_temperature_raw[3] <= maxttemp_raw[3]) {
#else
if(current_temperature_raw[3] >= maxttemp_raw[3]) {
#endif
max_temp_error(3);
}
#if HEATER_3_RAW_LO_TEMP > HEATER_3_RAW_HI_TEMP
if(current_temperature_raw[3] >= minttemp_raw[3]) {
#else
if(current_temperature_raw[3] <= minttemp_raw[3]) {
#endif
min_temp_error(3);
}
#endif
/* No bed MINTEMP error? */ /* No bed MINTEMP error? */
#if defined(BED_MAXTEMP) && (TEMP_SENSOR_BED != 0) #if defined(BED_MAXTEMP) && (TEMP_SENSOR_BED != 0)
# if HEATER_BED_RAW_LO_TEMP > HEATER_BED_RAW_HI_TEMP if (current_temperature_bed_raw MAXTEST bed_maxttemp_raw) {
if(current_temperature_bed_raw <= bed_maxttemp_raw) {
#else
if(current_temperature_bed_raw >= bed_maxttemp_raw) {
#endif
target_temperature_bed = 0; target_temperature_bed = 0;
bed_max_temp_error(); bed_max_temp_error();
} }
#endif #endif
} } // temp_count >= OVERSAMPLENR
#ifdef BABYSTEPPING #ifdef BABYSTEPPING
for(uint8_t axis=0;axis<3;axis++) for (uint8_t axis=X_AXIS; axis<=Z_AXIS; axis++) {
{
int curTodo=babystepsTodo[axis]; //get rid of volatile for performance int curTodo=babystepsTodo[axis]; //get rid of volatile for performance
if(curTodo>0) if (curTodo > 0) {
{
babystep(axis,/*fwd*/true); babystep(axis,/*fwd*/true);
babystepsTodo[axis]--; //less to do next time babystepsTodo[axis]--; //less to do next time
} }
else else if(curTodo < 0) {
if(curTodo<0)
{
babystep(axis,/*fwd*/false); babystep(axis,/*fwd*/false);
babystepsTodo[axis]++; //less to do next time babystepsTodo[axis]++; //less to do next time
} }
} }
#endif //BABYSTEPPING #endif //BABYSTEPPING
} }
#ifdef PIDTEMP #ifdef PIDTEMP
// Apply the scale factors to the PID values // 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_i(float i) float scalePID_d(float d) { return d / PID_dT; }
{ float unscalePID_d(float d) { return d * PID_dT; }
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;
}
#endif //PIDTEMP #endif //PIDTEMP

109
Marlin/temperature.h
View file

@ -85,55 +85,25 @@ extern float current_temperature_bed;
//inline so that there is no performance decrease. //inline so that there is no performance decrease.
//deg=degreeCelsius //deg=degreeCelsius
FORCE_INLINE float degHotend(uint8_t extruder) { FORCE_INLINE float degHotend(uint8_t extruder) { return current_temperature[extruder]; }
return current_temperature[extruder]; FORCE_INLINE float degBed() { return current_temperature_bed; }
};
#ifdef SHOW_TEMP_ADC_VALUES #ifdef SHOW_TEMP_ADC_VALUES
FORCE_INLINE float rawHotendTemp(uint8_t extruder) { FORCE_INLINE float rawHotendTemp(uint8_t extruder) { return current_temperature_raw[extruder]; }
return current_temperature_raw[extruder]; FORCE_INLINE float rawBedTemp() { return current_temperature_bed_raw; }
};
FORCE_INLINE float rawBedTemp() {
return current_temperature_bed_raw;
};
#endif #endif
FORCE_INLINE float degBed() { FORCE_INLINE float degTargetHotend(uint8_t extruder) { return target_temperature[extruder]; }
return current_temperature_bed; FORCE_INLINE float degTargetBed() { return target_temperature_bed; }
};
FORCE_INLINE float degTargetHotend(uint8_t extruder) { FORCE_INLINE void setTargetHotend(const float &celsius, uint8_t extruder) { target_temperature[extruder] = celsius; }
return target_temperature[extruder]; FORCE_INLINE void setTargetBed(const float &celsius) { target_temperature_bed = celsius; }
};
FORCE_INLINE float degTargetBed() { FORCE_INLINE bool isHeatingHotend(uint8_t extruder) { return target_temperature[extruder] > current_temperature[extruder]; }
return target_temperature_bed; FORCE_INLINE bool isHeatingBed() { return target_temperature_bed > current_temperature_bed; }
};
FORCE_INLINE void setTargetHotend(const float &celsius, uint8_t extruder) { FORCE_INLINE bool isCoolingHotend(uint8_t extruder) { return target_temperature[extruder] < current_temperature[extruder]; }
target_temperature[extruder] = celsius; FORCE_INLINE bool isCoolingBed() { return target_temperature_bed < current_temperature_bed; }
};
FORCE_INLINE void setTargetBed(const float &celsius) {
target_temperature_bed = celsius;
};
FORCE_INLINE bool isHeatingHotend(uint8_t extruder){
return target_temperature[extruder] > current_temperature[extruder];
};
FORCE_INLINE bool isHeatingBed() {
return target_temperature_bed > current_temperature_bed;
};
FORCE_INLINE bool isCoolingHotend(uint8_t extruder) {
return target_temperature[extruder] < current_temperature[extruder];
};
FORCE_INLINE bool isCoolingBed() {
return target_temperature_bed < current_temperature_bed;
};
#define degHotend0() degHotend(0) #define degHotend0() degHotend(0)
#define degTargetHotend0() degTargetHotend(0) #define degTargetHotend0() degTargetHotend(0)
@ -141,38 +111,36 @@ FORCE_INLINE bool isCoolingBed() {
#define isHeatingHotend0() isHeatingHotend(0) #define isHeatingHotend0() isHeatingHotend(0)
#define isCoolingHotend0() isCoolingHotend(0) #define isCoolingHotend0() isCoolingHotend(0)
#if EXTRUDERS > 1 #if EXTRUDERS > 1
#define degHotend1() degHotend(1) #define degHotend1() degHotend(1)
#define degTargetHotend1() degTargetHotend(1) #define degTargetHotend1() degTargetHotend(1)
#define setTargetHotend1(_celsius) setTargetHotend((_celsius), 1) #define setTargetHotend1(_celsius) setTargetHotend((_celsius), 1)
#define isHeatingHotend1() isHeatingHotend(1) #define isHeatingHotend1() isHeatingHotend(1)
#define isCoolingHotend1() isCoolingHotend(1) #define isCoolingHotend1() isCoolingHotend(1)
#else #else
#define setTargetHotend1(_celsius) do{}while(0) #define setTargetHotend1(_celsius) do{}while(0)
#endif #endif
#if EXTRUDERS > 2 #if EXTRUDERS > 2
#define degHotend2() degHotend(2) #define degHotend2() degHotend(2)
#define degTargetHotend2() degTargetHotend(2) #define degTargetHotend2() degTargetHotend(2)
#define setTargetHotend2(_celsius) setTargetHotend((_celsius), 2) #define setTargetHotend2(_celsius) setTargetHotend((_celsius), 2)
#define isHeatingHotend2() isHeatingHotend(2) #define isHeatingHotend2() isHeatingHotend(2)
#define isCoolingHotend2() isCoolingHotend(2) #define isCoolingHotend2() isCoolingHotend(2)
#else #else
#define setTargetHotend2(_celsius) do{}while(0) #define setTargetHotend2(_celsius) do{}while(0)
#endif #endif
#if EXTRUDERS > 3 #if EXTRUDERS > 3
#define degHotend3() degHotend(3) #define degHotend3() degHotend(3)
#define degTargetHotend3() degTargetHotend(3) #define degTargetHotend3() degTargetHotend(3)
#define setTargetHotend3(_celsius) setTargetHotend((_celsius), 3) #define setTargetHotend3(_celsius) setTargetHotend((_celsius), 3)
#define isHeatingHotend3() isHeatingHotend(3) #define isHeatingHotend3() isHeatingHotend(3)
#define isCoolingHotend3() isCoolingHotend(3) #define isCoolingHotend3() isCoolingHotend(3)
#else #else
#define setTargetHotend3(_celsius) do{}while(0) #define setTargetHotend3(_celsius) do{}while(0)
#endif #endif
#if EXTRUDERS > 4 #if EXTRUDERS > 4
#error Invalid number of extruders #error Invalid number of extruders
#endif #endif
int getHeaterPower(int heater); int getHeaterPower(int heater);
void disable_heater(); void disable_heater();
void setWatch(); void setWatch();
@ -189,15 +157,14 @@ static bool thermal_runaway = false;
#endif #endif
#endif #endif
FORCE_INLINE void autotempShutdown(){ FORCE_INLINE void autotempShutdown() {
#ifdef AUTOTEMP #ifdef AUTOTEMP
if(autotemp_enabled) if (autotemp_enabled) {
{ autotemp_enabled = false;
autotemp_enabled=false; if (degTargetHotend(active_extruder) > autotemp_min)
if(degTargetHotend(active_extruder)>autotemp_min) setTargetHotend(0, active_extruder);
setTargetHotend(0,active_extruder);
} }
#endif #endif
} }
void PID_autotune(float temp, int extruder, int ncycles); void PID_autotune(float temp, int extruder, int ncycles);