search

MarlinFirmware / Marlin

Marlin is an optimized firmware for RepRap 3D printers based on the Arduino platform. Many commercial 3D printers come with Marlin installed. Check with your vendor if you need source code for your specific machine.
https://marlinfw.org
GNU General Public License v3.0
16.24k stars 19.22k forks source link

Multiple extruders (6) with temperature.cpp #995

Closed PatONeil closed 9 years ago

PatONeil commented 10 years ago

I have rewritten temperature.cpp to handle a variable number of extruders. I am currently using 6 extruders and the code seems to be working fine.

However, I am having trouble keeping temperatures within a tolerable range. Can anyone suggest why (even after pid tuning), I cannot manage temperatures within 20 degrees . The modified code is:

include "Marlin.h"

include "ultralcd.h"

include "temperature.h"

include "watchdog.h"

//=========================================================================== //=============================public variables============================ //=========================================================================== int target_temperature[EXTRUDERS] = { 0 }; int target_temperature_bed = 0; int current_temperature_raw[EXTRUDERS] = { 0 }; float current_temperature[EXTRUDERS] = { 0.0 }; int current_temperature_bed_raw = 0; float current_temperature_bed = 0.0;

ifdef TEMP_SENSOR_1_AS_REDUNDANT

int redundant_temperature_raw = 0; float redundant_temperature = 0.0;

endif

ifdef PIDTEMP

float Kp=DEFAULT_Kp; float Ki=(DEFAULT_Ki*PID_dT); float Kd=(DEFAULT_Kd/PID_dT);

ifdef PID_ADD_EXTRUSION_RATE

float Kc=DEFAULT_Kc;

endif

endif //PIDTEMP

ifdef PIDTEMPBED

float bedKp=DEFAULT_bedKp; float bedKi=(DEFAULT_bedKi*PID_dT); float bedKd=(DEFAULT_bedKd/PID_dT);

endif //PIDTEMPBED

ifdef FAN_SOFT_PWM

unsigned char fanSpeedSoftPwm;

endif

unsigned char soft_pwm_bed;

ifdef BABYSTEPPING

volatile int babystepsTodo[3]={0,0,0};

endif

//=========================================================================== //=============================private variables============================ //=========================================================================== static volatile bool temp_meas_ready = false;

ifdef PIDTEMP

//static cannot be external: static float temp_iState[EXTRUDERS] = { 0 }; static float temp_dState[EXTRUDERS] = { 0 }; static float pTerm[EXTRUDERS]; static float iTerm[EXTRUDERS]; static float dTerm[EXTRUDERS]; //int output; static float pid_error[EXTRUDERS]; static float temp_iState_min[EXTRUDERS]; static float temp_iState_max[EXTRUDERS]; // static float pid_input[EXTRUDERS]; // static float pid_output[EXTRUDERS]; static bool pid_reset[EXTRUDERS];

endif //PIDTEMP

ifdef PIDTEMPBED

//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;

else //PIDTEMPBED

static unsigned long  previous_millis_bed_heater;

endif //PIDTEMPBED

static unsigned char soft_pwm[EXTRUDERS];

ifdef FAN_SOFT_PWM

static unsigned char soft_pwm_fan;

endif

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_2_AUTO_FAN_PIN) && EXTRUDER_2_AUTO_FAN_PIN > -1)

static unsigned long extruder_autofan_last_check;

endif

// Init min and max temp with extreme values to prevent false errors during startup
static int minttemp_raw[EXTRUDERS];
static int maxttemp_raw[EXTRUDERS]; 
static int minttemp[EXTRUDERS];
static int maxttemp[EXTRUDERS]; 
static void *heater_ttbl_map[EXTRUDERS];
static uint8_t heater_ttbllen_map[EXTRUDERS];
int watch_start_temp[EXTRUDERS];
unsigned long watchmillis[EXTRUDERS];

//static int bed_minttemp_raw = HEATER_BED_RAW_LO_TEMP; /* No bed mintemp error implemented?!? */

ifdef BED_MAXTEMP

static int bed_maxttemp_raw = HEATER_BED_RAW_HI_TEMP;

endif

static float analog2temp(int raw, uint8_t e); static float analog2tempBed(int raw); static void updateTemperaturesFromRawValues();

ifndef SOFT_PWM_SCALE

define SOFT_PWM_SCALE 0

endif

//=========================================================================== //============================= functions ============================ //===========================================================================

void PID_autotune(float temp, int extruder, int ncycles) { float input = 0.0; int cycles=0; bool heating = true;

unsigned long temp_millis = millis(); unsigned long t1=temp_millis; unsigned long t2=temp_millis; long t_high = 0; long t_low = 0;

long bias, d; float Ku, Tu; float Kp, Ki, Kd; float max = 0, min = 10000;

if ((extruder > EXTRUDERS)

if (TEMP_BED_PIN <= -1)

   ||(extruder < 0)

endif

   ){
      SERIAL_ECHOLN("PID Autotune failed. Bad extruder number.");
      return;
    }

SERIAL_ECHOLN("PID Autotune start");

disable_heater(); // switch off all heaters.

if (extruder<0) { soft_pwm_bed = (MAX_BED_POWER)/2; bias = d = (MAX_BED_POWER)/2; } else { soft_pwm[extruder] = (PID_MAX)/2; bias = d = (PID_MAX)/2; }

for(;;) {

if(temp_meas_ready == true) { // temp sample ready
  updateTemperaturesFromRawValues();

  input = (extruder<0)?current_temperature_bed:current_temperature[extruder];

  max=max(max,input);
  min=min(min,input);
  if(heating == true && input > temp) {
    if(millis() - t2 > 5000) { 
      heating=false;
      if (extruder<0)
        soft_pwm_bed = (bias - d) >> 1;
      else
        soft_pwm[extruder] = (bias - d) >> 1;
      t1=millis();
      t_high=t1 - t2;
      max=temp;
    }
  }
  if(heating == false && input < temp) {
    if(millis() - t1 > 5000) {
      heating=true;
      t2=millis();
      t_low=t2 - t1;
      if(cycles > 0) {
        bias += (d*(t_high - t_low))/(t_low + t_high);
        bias = constrain(bias, 20 ,(extruder<0?(MAX_BED_POWER):(PID_MAX))-20);
        if(bias > (extruder<0?(MAX_BED_POWER):(PID_MAX))/2) d = (extruder<0?(MAX_BED_POWER):(PID_MAX)) - 1 - bias;
        else d = bias;

        SERIAL_PROTOCOLPGM(" bias: "); SERIAL_PROTOCOL(bias);
        SERIAL_PROTOCOLPGM(" d: "); SERIAL_PROTOCOL(d);
        SERIAL_PROTOCOLPGM(" min: "); SERIAL_PROTOCOL(min);
        SERIAL_PROTOCOLPGM(" max: "); SERIAL_PROTOCOLLN(max);
        if(cycles > 2) {
          Ku = (4.0*d)/(3.14159*(max-min)/2.0);
          Tu = ((float)(t_low + t_high)/1000.0);
          SERIAL_PROTOCOLPGM(" Ku: "); SERIAL_PROTOCOL(Ku);
          SERIAL_PROTOCOLPGM(" Tu: "); SERIAL_PROTOCOLLN(Tu);
          Kp = 0.6*Ku;
          Ki = 2*Kp/Tu;
          Kd = Kp*Tu/8;
          SERIAL_PROTOCOLLNPGM(" Classic PID ");
          SERIAL_PROTOCOLPGM(" Kp: "); SERIAL_PROTOCOLLN(Kp);
          SERIAL_PROTOCOLPGM(" Ki: "); SERIAL_PROTOCOLLN(Ki);
          SERIAL_PROTOCOLPGM(" Kd: "); SERIAL_PROTOCOLLN(Kd);
          /*
          Kp = 0.33*Ku;
          Ki = Kp/Tu;
          Kd = Kp*Tu/3;
          SERIAL_PROTOCOLLNPGM(" Some overshoot ")
          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;
          SERIAL_PROTOCOLLNPGM(" No overshoot ")
          SERIAL_PROTOCOLPGM(" Kp: "); SERIAL_PROTOCOLLN(Kp);
          SERIAL_PROTOCOLPGM(" Ki: "); SERIAL_PROTOCOLLN(Ki);
          SERIAL_PROTOCOLPGM(" Kd: "); SERIAL_PROTOCOLLN(Kd);
          */
        }
      }
      if (extruder<0)
        soft_pwm_bed = (bias + d) >> 1;
      else
        soft_pwm[extruder] = (bias + d) >> 1;
      cycles++;
      min=temp;
    }
  } 
}
if(input > (temp + 20)) {
  SERIAL_PROTOCOLLNPGM("PID Autotune failed! Temperature too high");
  return;
}
if(millis() - temp_millis > 2000) {
  int p;
  if (extruder<0){
    p=soft_pwm_bed;       
    SERIAL_PROTOCOLPGM("ok B:");
  }else{
    p=soft_pwm[extruder];       
    SERIAL_PROTOCOLPGM("ok T:");
  }

  SERIAL_PROTOCOL(input);   
  SERIAL_PROTOCOLPGM(" @:");
  SERIAL_PROTOCOLLN(p);       

  temp_millis = millis();
}
if(((millis() - t1) + (millis() - t2)) > (10L*60L*1000L*2L)) {
  SERIAL_PROTOCOLLNPGM("PID Autotune failed! timeout");
  return;
}
if(cycles > ncycles) {
  SERIAL_PROTOCOLLNPGM("PID Autotune finished! Put the last Kp, Ki and Kd constants from above into Configuration.h");
  return;
}
lcd_update();

} }

void updatePID() {

ifdef PIDTEMP

for(int e = 0; e < EXTRUDERS; e++) { temp_iState_max[e] = PID_INTEGRAL_DRIVE_MAX / Ki;
}

endif

ifdef PIDTEMPBED

temp_iState_max_bed = PID_INTEGRAL_DRIVE_MAX / bedKi;

endif

}

int getHeaterPower(int heater) { if (heater<0) return soft_pwm_bed; return soft_pwm[heater]; }

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_2_AUTO_FAN_PIN) && EXTRUDER_2_AUTO_FAN_PIN > -1)

if defined(FAN_PIN) && FAN_PIN > -1

#if EXTRUDER_0_AUTO_FAN_PIN == FAN_PIN 
   #error "You cannot set EXTRUDER_0_AUTO_FAN_PIN equal to FAN_PIN"
#endif
#if EXTRUDER_1_AUTO_FAN_PIN == FAN_PIN 
   #error "You cannot set EXTRUDER_1_AUTO_FAN_PIN equal to FAN_PIN"
#endif
#if EXTRUDER_2_AUTO_FAN_PIN == FAN_PIN 
   #error "You cannot set EXTRUDER_2_AUTO_FAN_PIN equal to FAN_PIN"
#endif

endif

void setExtruderAutoFanState(int pin, bool state) { unsigned char newFanSpeed = (state != 0) ? EXTRUDER_AUTO_FAN_SPEED : 0; // this idiom allows both digital and PWM fan outputs (see M42 handling). pinMode(pin, OUTPUT); digitalWrite(pin, newFanSpeed); analogWrite(pin, newFanSpeed); }

void checkExtruderAutoFans() { uint8_t fanState = 0;

// which fan pins need to be turned on?

if defined(EXTRUDER_0_AUTO_FAN_PIN) && EXTRUDER_0_AUTO_FAN_PIN > -1

if (current_temperature[0] > EXTRUDER_AUTO_FAN_TEMPERATURE) 
  fanState |= 1;

endif

if defined(EXTRUDER_1_AUTO_FAN_PIN) && EXTRUDER_1_AUTO_FAN_PIN > -1

if (current_temperature[1] > EXTRUDER_AUTO_FAN_TEMPERATURE) 
{
  if (EXTRUDER_1_AUTO_FAN_PIN == EXTRUDER_0_AUTO_FAN_PIN) 
    fanState |= 1;
  else
    fanState |= 2;
}

endif

if defined(EXTRUDER_2_AUTO_FAN_PIN) && EXTRUDER_2_AUTO_FAN_PIN > -1

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

// update extruder auto fan states

if defined(EXTRUDER_0_AUTO_FAN_PIN) && EXTRUDER_0_AUTO_FAN_PIN > -1

setExtruderAutoFanState(EXTRUDER_0_AUTO_FAN_PIN, (fanState & 1) != 0);

endif

if defined(EXTRUDER_1_AUTO_FAN_PIN) && EXTRUDER_1_AUTO_FAN_PIN > -1

if (EXTRUDER_1_AUTO_FAN_PIN != EXTRUDER_0_AUTO_FAN_PIN) 
  setExtruderAutoFanState(EXTRUDER_1_AUTO_FAN_PIN, (fanState & 2) != 0);

endif

if defined(EXTRUDER_2_AUTO_FAN_PIN) && EXTRUDER_2_AUTO_FAN_PIN > -1

if (EXTRUDER_2_AUTO_FAN_PIN != EXTRUDER_0_AUTO_FAN_PIN 
    && EXTRUDER_2_AUTO_FAN_PIN != EXTRUDER_1_AUTO_FAN_PIN)
  setExtruderAutoFanState(EXTRUDER_2_AUTO_FAN_PIN, (fanState & 4) != 0);

endif

}

endif // any extruder auto fan pins set

void manage_heater() { float pid_input; float pid_output;

if(temp_meas_ready != true) //better readability return;

updateTemperaturesFromRawValues();

for(int e = 0; e < EXTRUDERS; e++) {

ifdef PIDTEMP

pid_input = current_temperature[e];
#ifndef PID_OPENLOOP
    pid_error[e] = target_temperature[e] - pid_input;
    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] == true) {
        temp_iState[e] = 0.0;
        pid_reset[e] = false;
      }
      pTerm[e] = Kp * 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] = Ki * temp_iState[e];

      //K1 defined in Configuration.h in the PID settings
      #define K2 (1.0-K1)
      dTerm[e] = (Kd * (pid_input - temp_dState[e]))*K2 + (K1 * dTerm[e]);
      pid_output = constrain(pTerm[e] + iTerm[e] - dTerm[e], 0, PID_MAX);
    }
    temp_dState[e] = pid_input;
#else 
      pid_output = constrain(target_temperature[e], 0, PID_MAX);
#endif //PID_OPENLOOP
#ifdef PID_DEBUG
SERIAL_ECHO_START;
SERIAL_ECHO(" PID_DEBUG ");
SERIAL_ECHO(e);
SERIAL_ECHO(": Input ");
SERIAL_ECHO(pid_input);
SERIAL_ECHO(" Output ");
SERIAL_ECHO(pid_output);
SERIAL_ECHO(" pTerm ");
SERIAL_ECHO(pTerm[e]);
SERIAL_ECHO(" iTerm ");
SERIAL_ECHO(iTerm[e]);
SERIAL_ECHO(" dTerm ");
SERIAL_ECHOLN(dTerm[e]);  
#endif //PID_DEBUG

else /* PID off */

pid_output = 0;
if(current_temperature[e] < target_temperature[e]) {
  pid_output = PID_MAX;
}

endif

// Check if temperature is within the correct range
if((current_temperature[e] > minttemp[e]) && (current_temperature[e] < maxttemp[e])) 
{
  soft_pwm[e] = (int)pid_output >> 1;
}
else {
  soft_pwm[e] = 0;
}

#ifdef WATCH_TEMP_PERIOD
if(watchmillis[e] && millis() - watchmillis[e] > WATCH_TEMP_PERIOD)
{
    if(degHotend(e) < watch_start_temp[e] + WATCH_TEMP_INCREASE)
    {
        setTargetHotend(0, e);
        LCD_MESSAGEPGM("Heating failed");
        SERIAL_ECHO_START;
        SERIAL_ECHOLN("Heating failed");
    }else{
        watchmillis[e] = 0;
    }
}
#endif
#ifdef TEMP_SENSOR_1_AS_REDUNDANT
  if(fabs(current_temperature[0] - redundant_temperature) > MAX_REDUNDANT_TEMP_SENSOR_DIFF) {
    disable_heater();
    if(IsStopped() == false) {
      SERIAL_ERROR_START;
      SERIAL_ERRORLNPGM("Extruder switched off. Temperature difference between temp sensors is too high !");
      LCD_ALERTMESSAGEPGM("Err: REDUNDANT TEMP ERROR");
    }
    #ifndef BOGUS_TEMPERATURE_FAILSAFE_OVERRIDE
      Stop();
    #endif
  }
#endif

} // End extruder for loop

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_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 { checkExtruderAutoFans(); extruder_autofan_last_check = millis(); }

endif

ifndef PIDTEMPBED

if(millis() - previous_millis_bed_heater < BED_CHECK_INTERVAL) return; previous_millis_bed_heater = millis();

endif

if TEMP_SENSOR_BED != 0

ifdef PIDTEMPBED

pid_input = current_temperature_bed;
#ifndef PID_OPENLOOP
      pid_error_bed = target_temperature_bed - pid_input;
      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;

      //K1 defined in Configuration.h in the PID settings
      #define K2 (1.0-K1)
      dTerm_bed= (bedKd * (pid_input - temp_dState_bed))*K2 + (K1 * dTerm_bed);
      temp_dState_bed = pid_input;

      pid_output = constrain(pTerm_bed + iTerm_bed - dTerm_bed, 0, MAX_BED_POWER);

#else 
  pid_output = constrain(target_temperature_bed, 0, MAX_BED_POWER);
#endif //PID_OPENLOOP

  if((current_temperature_bed > BED_MINTEMP) && (current_temperature_bed < BED_MAXTEMP)) 
  {
    soft_pwm_bed = (int)pid_output >> 1;
  }
  else {
    soft_pwm_bed = 0;
  }

#elif !defined(BED_LIMIT_SWITCHING)
  // Check if temperature is within the correct range
  if((current_temperature_bed > BED_MINTEMP) && (current_temperature_bed < BED_MAXTEMP))
  {
    if(current_temperature_bed >= target_temperature_bed)
    {
      soft_pwm_bed = 0;
    }
    else 
    {
      soft_pwm_bed = MAX_BED_POWER>>1;
    }
  }
  else
  {
    soft_pwm_bed = 0;
    WRITE(HEATER_BED_PIN,LOW);
  }
#else //#ifdef BED_LIMIT_SWITCHING
  // Check if temperature is within the correct band
  if((current_temperature_bed > BED_MINTEMP) && (current_temperature_bed < BED_MAXTEMP))
  {
    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;
    }
  }
  else
  {
    soft_pwm_bed = 0;
    WRITE(HEATER_BED_PIN,LOW);
  }
#endif

endif

}

define PGM_RD_W(x) (short)pgm_read_word(&x)

// Derived from RepRap FiveD extruder::getTemperature() // For hot end temperature measurement. static float analog2temp(int raw, uint8_t e) {

ifdef TEMP_SENSOR_1_AS_REDUNDANT

if(e > EXTRUDERS)

else

if(e >= EXTRUDERS)

endif

{ SERIAL_ERROR_START;

ifdef CAROUSEL_CARRIAGE

  SERIAL_ECHOPAIR(" Extruders=",(unsigned long)EXTRUDERS);
  SERIAL_ECHOPAIR(" but requested extruder=",(unsigned long)(e));

endif

  SERIAL_ERROR((int)e);
  SERIAL_ERRORLNPGM(" - Invalid extruder number !");
  kill();

}

ifdef HEATER_0_USES_MAX6675

if (e == 0)
{
  return 0.25 \* raw;
}

endif

if(heater_ttbl_map[e] != NULL) { float celsius = 0; uint8_t i; short (tt)[][2] = (short ()[][2])(heater_ttbl_map[e]);

for (i=1; i<heater_ttbllen_map[e]; i++)
{
  if (PGM_RD_W((*tt)[i][0]) > raw)
  {
    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]));
    break;
  }
}

// Overflow: Set to last value in the table
if (i == heater_ttbllen_map[e]) celsius = PGM_RD_W((*tt)[i-1][1]);

return celsius;

} return ((raw * ((5.0 * 100.0) / 1024.0) / OVERSAMPLENR) * TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET; }

// Derived from RepRap FiveD extruder::getTemperature() // For bed temperature measurement. static float analog2tempBed(int raw) {

ifdef BED_USES_THERMISTOR

float celsius = 0;
byte i;
for (i=1; i<BEDTEMPTABLE_LEN; i++)
{
  if (PGM_RD_W(BEDTEMPTABLE[i][0]) > raw)
  {
    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]));
    break;
  }
}

// Overflow: Set to last value in the table
if (i == BEDTEMPTABLE_LEN) celsius = PGM_RD_W(BEDTEMPTABLE[i-1][1]);

return celsius;

elif defined BED_USES_AD595

return ((raw \* ((5.0 \* 100.0) / 1024.0) / OVERSAMPLENR) \* TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET;

else

return 0;

endif

}

/* 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 */ static void updateTemperaturesFromRawValues() { for(uint8_t e=0;e<EXTRUDERS;e++) { if (e>8) { SERIAL_ERROR_START; SERIAL_ECHOPAIR("updateTemperaturesFromRawValues Extruders=",(unsigned long)EXTRUDERS); SERIAL_ECHOPAIR(" but requested extruder=",(unsigned long)(e)); SERIAL_ERROR((int)e); SERIAL_ERRORLNPGM(" - Invalid extruder number !"); kill(); } current_temperature[e] = analog2temp(current_temperature_raw[e], e); } current_temperature_bed = analog2tempBed(current_temperature_bed_raw);

ifdef TEMP_SENSOR_1_AS_REDUNDANT

  redundant_temperature = analog2temp(redundant_temperature_raw, 1);
#endif
//Reset the watchdog after we know we have a temperature measurement.
watchdog_reset();
CRITICAL_SECTION_START;
temp_meas_ready = false;
CRITICAL_SECTION_END;

}

void tp_init() { // Support for multiple extruders without complicated code. SERIAL_ECHO_START; for (int8_t i = 0;i<EXTRUDERS;i++) { SERIAL_ECHOPAIR(" Extruder=",(unsigned long)(i)); SERIAL_ECHOPAIR(", heatPin=",(unsigned long)(e_pins[i][HEATER_PIN])); SERIAL_ECHOPAIR(", tempPin=",(unsigned long)(e_pins[i][TEMP_PIN])); minttemp_raw[i] = e_pins[i][HEATER_RAW_LO_TEMP]; SERIAL_ECHOPAIR(", minttemp_raw=",(unsigned long)(minttemp_raw[i])); maxttemp_raw[i] = e_pins[i][HEATER_RAW_HI_TEMP]; SERIAL_ECHOPAIR(", maxttemp_raw=",(unsigned long)(maxttemp_raw[i])); minttemp[i] = 0; SERIAL_ECHOPAIR(", minttemp=",(unsigned long)(minttemp[i])); maxttemp[i] = 16383; SERIAL_ECHOPAIR(", maxttemp=",(unsigned long)(maxttemp[i])); heater_ttbl_map[i] = (void *)e_pins[i][HEATER_TEMPTABLE]; SERIAL_ECHOPAIR(", heater_ttbl_map=",(unsigned long)(heater_ttbl_map[i])); heater_ttbllen_map[i] = e_pins[i][HEATER_TEMPTABLE_LEN]; SERIAL_ECHOPAIR(", heater_ttbllen_map=",(unsigned long)(heater_ttbllen_map[i])); watch_start_temp[i] = 0; watchmillis[i] = 0; SERIAL_ECHOLN(" "); // populate with the first value

ifdef PIDTEMP

temp_iState_min[i] = 0.0;
temp_iState_max[i] = PID_INTEGRAL_DRIVE_MAX / Ki;

endif //PIDTEMP

ifdef PIDTEMPBED

temp_iState_min_bed = 0.0;
temp_iState_max_bed = PID_INTEGRAL_DRIVE_MAX / bedKi;

endif //PIDTEMPBED

// set heater pin
if (e_pins[i][HEATER_PIN] > -1) pinMode(e_pins[i][HEATER_PIN],OUTPUT);  // we need to use integer so.. pinMode best if not fastest

}

if defined(HEATER_BED_PIN) && (HEATER_BED_PIN > -1)

SET_OUTPUT(HEATER_BED_PIN);

endif

if defined(FAN_PIN) && (FAN_PIN > -1)

SET_OUTPUT(FAN_PIN);
#ifdef FAST_PWM_FAN
setPwmFrequency(FAN_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
#endif
#ifdef FAN_SOFT_PWM
soft_pwm_fan = fanSpeedSoftPwm / 2;
#endif

endif

ifdef HEATER_0_USES_MAX6675

#ifndef SDSUPPORT
  SET_OUTPUT(MAX_SCK_PIN);
  WRITE(MAX_SCK_PIN,0);
  SET_OUTPUT(MAX_MOSI_PIN);
  WRITE(MAX_MOSI_PIN,1);

  SET_INPUT(MAX_MISO_PIN);
  WRITE(MAX_MISO_PIN,1);
#endif

SET_OUTPUT(MAX6675_SS);
WRITE(MAX6675_SS,1);

endif

// Set analog inputs ADCSRA = 1<<ADEN | 1<<ADSC | 1<<ADIF | 0x07; DIDR0 = 0;

ifdef DIDR2

DIDR2 = 0;

endif

for (int8_t i = 0;i<EXTRUDERS;i++) {
    if (e_pins[i][TEMP_PIN] > -1) {
        if (e_pins[i][TEMP_PIN] < 8) DIDR0 |= 1 << e_pins[i][TEMP_PIN];
        else DIDR2 |= 1<<(e_pins[i][TEMP_PIN] - 8); 
    }
}

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

// Use timer0 for temperature measurement // Interleave temperature interrupt with millies interrupt OCR0B = 128; TIMSK0 |= (1<<OCIE0B); 

// Wait for temperature measurement to settle
delay(250);
// wait for extruders to be in min/max range
for (int8_t i = 0;i<EXTRUDERS;i++) {
    if (e_pins[i][HEATER_MIN_TEMP]!=0) {
        while(analog2temp(minttemp_raw[i], i) < e_pins[i][HEATER_MIN_TEMP]) {
            if (e_pins[i][HEATER_RAW_LO_TEMP] < e_pins[i][HEATER_RAW_HI_TEMP]) minttemp_raw[i] += OVERSAMPLENR;
            else minttemp_raw[i] -= OVERSAMPLENR;
        }   
    }
    if (e_pins[i][HEATER_MAX_TEMP]!=0) {
        while(analog2temp(maxttemp_raw[i], i) < e_pins[i][HEATER_MAX_TEMP]) {
            if (e_pins[i][HEATER_RAW_LO_TEMP] < e_pins[i][HEATER_RAW_HI_TEMP]) maxttemp_raw[i] -= OVERSAMPLENR;
            else maxttemp_raw[i] += OVERSAMPLENR;
        }   
    }
}

ifdef BED_MINTEMP

/* No bed MINTEMP error implemented?!? / / 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

}

void setWatch() {

ifdef WATCH_TEMP_PERIOD

for (int e = 0; e < EXTRUDERS; e++) { if(degHotend(e) < degTargetHotend(e) - (WATCH_TEMP_INCREASE * 2)) { watch_start_temp[e] = degHotend(e); watchmillis[e] = millis(); } }

endif

}

void disable_heater() { for(int i=0;i<EXTRUDERS;i++) { setTargetHotend(0,i); if (e_pins[i][TEMP_PIN] > -1) { target_temperature[i]=0; soft_pwm[i]=0; if (e_pins[i][HEATER_PIN] > -1) digitalWrite(e_pins[i][HEATER_PIN],LOW); }

}
setTargetBed(0);
#if defined(TEMP_BED_PIN) && TEMP_BED_PIN > -1
    target_temperature_bed=0;
    soft_pwm_bed=0;
    #if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1  
        WRITE(HEATER_BED_PIN,LOW);
    #endif
#endif

}

void max_temp_error(uint8_t e) { disable_heater(); if(IsStopped() == false) { SERIAL_ERROR_START; SERIAL_ERRORLN((int)e); SERIAL_ERRORLNPGM(": Extruder switched off. MAXTEMP triggered !"); LCD_ALERTMESSAGEPGM("Err: MAXTEMP"); }

ifndef BOGUS_TEMPERATURE_FAILSAFE_OVERRIDE

Stop();

endif

}

void min_temp_error(uint8_t e) { disable_heater(); if(IsStopped() == false) { SERIAL_ERROR_START; SERIAL_ERRORLN((int)e); SERIAL_ERRORLNPGM(": Extruder switched off. MINTEMP triggered !"); LCD_ALERTMESSAGEPGM("Err: MINTEMP"); }

ifndef BOGUS_TEMPERATURE_FAILSAFE_OVERRIDE

Stop();

endif

}

void bed_max_temp_error(void) {

if HEATER_BED_PIN > -1

WRITE(HEATER_BED_PIN, 0);

endif

if(IsStopped() == false) { SERIAL_ERROR_START; SERIAL_ERRORLNPGM("Temperature heated bed switched off. MAXTEMP triggered !!"); LCD_ALERTMESSAGEPGM("Err: MAXTEMP BED"); }

ifndef BOGUS_TEMPERATURE_FAILSAFE_OVERRIDE

Stop();

endif

}

ifdef HEATER_0_USES_MAX6675

define MAX6675_HEAT_INTERVAL 250

long max6675_previous_millis = -HEAT_INTERVAL; int max6675_temp = 2000;

int read_max6675() { if (millis() - max6675_previous_millis < MAX6675_HEAT_INTERVAL) return max6675_temp;

max6675_previous_millis = millis(); max6675_temp = 0;

ifdef PRR

PRR &= ~(1<<PRSPI);

elif defined PRR0

PRR0 &= ~(1<<PRSPI);

endif

SPCR = (1<<MSTR) | (1<<SPE) | (1<<SPR0);

// 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

// read MSB SPDR = 0; for (;(SPSR & (1<<SPIF)) == 0;); max6675_temp = SPDR; max6675_temp <<= 8;

// read LSB SPDR = 0; for (;(SPSR & (1<<SPIF)) == 0;); max6675_temp |= SPDR;

// disable TT_MAX6675 WRITE(MAX6675_SS, 1);

if (max6675_temp & 4) { // thermocouple open max6675_temp = 2000; } else { max6675_temp = max6675_temp >> 3; }

return max6675_temp; }

endif

// Timer 0 is shared with millies ISR(TIMER0_COMPB_vect) { //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 long raw_temp_value[EXTRUDERS]={0}; static unsigned long raw_temp_bed_value = 0; static unsigned char temp_state = 0; static unsigned char pwm_count = (1 << SOFT_PWM_SCALE); static unsigned char isr_soft_pwm[EXTRUDERS]={0};

if HEATER_BED_PIN > -1

    static unsigned char soft_pwm_b;
#endif
if(pwm_count == 0){
    for(int i=0;i<EXTRUDERS;i++) {
        isr_soft_pwm[i]=soft_pwm[i];
        if (isr_soft_pwm[i] > 0) digitalWrite(e_pins[i][HEATER_PIN],1);
        else                     digitalWrite(e_pins[i][HEATER_PIN],0);
        if (isr_soft_pwm[i] < pwm_count) digitalWrite(e_pins[i][HEATER_PIN],0);
    }
    #if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
        soft_pwm_b = soft_pwm_bed;
        if(soft_pwm_b > 0) digitalWrite(HEATER_BED_PIN,1); else digitalWrite(HEATER_BED_PIN,0);
    #endif
    #ifdef FAN_SOFT_PWM
        soft_pwm_fan = fanSpeedSoftPwm / 2;
        if(soft_pwm_fan > 0) WRITE(FAN_PIN,1); else WRITE(FAN_PIN,0);
    #endif
}
#if defined(HEATER_BED_PIN) && HEATER_BED_PIN > -1
    if(soft_pwm_b < pwm_count) WRITE(HEATER_BED_PIN,0);
#endif
#ifdef FAN_SOFT_PWM
    if(soft_pwm_fan < pwm_count) WRITE(FAN_PIN,0);
#endif

pwm_count += (1 << SOFT_PWM_SCALE);
pwm_count &= 0x7f;
unsigned int extruder = temp_state>>1;
if (temp_state % 2==0) {
    if (e_pins[extruder][TEMP_PIN] > -1 ){
        if (e_pins[extruder][TEMP_PIN] > 7 ) ADCSRB = 1<<MUX5;
        else ADCSRB = 0;
        ADMUX = ((1 << REFS0) | (e_pins[extruder][TEMP_PIN] & 0x07));
        ADCSRA |= 1<<ADSC; // Start conversion
    }
    lcd_buttons_update();
}
else {
    if (e_pins[extruder][TEMP_PIN] > -1 ) raw_temp_value[extruder] += ADC;
}

temp_state++;
if (temp_state >= (EXTRUDERS*2)) {
    temp_state=0;
    temp_count++;
}   
if(temp_count >= OVERSAMPLENR) {// 8 * 16 * 1/(16000000/64/256)  = 131ms.
    if (!temp_meas_ready) {//Only update the raw values if they have been read. Else we could be updating them during reading.
        for (int i=0;i<EXTRUDERS;i++) {
            current_temperature_raw[i] = raw_temp_value[i];
        }
        current_temperature_bed_raw = raw_temp_bed_value;
    }
    temp_meas_ready = true;
    temp_count = 0;
    for (int i=0;i<EXTRUDERS;i++) {
        raw_temp_value[i] = 0;
        if (e_pins[extruder][HEATER_RAW_LO_TEMP] > e_pins[extruder][HEATER_RAW_HI_TEMP]) {
            if(current_temperature_raw[i] <= maxttemp_raw[i]) max_temp_error(0);
        }
        else {
            if(current_temperature_raw[i] >= maxttemp_raw[i]) max_temp_error(0);
        }
    }
    raw_temp_bed_value = 0;

}
/* No bed MINTEMP error? */
#if defined(BED_MAXTEMP) && (TEMP_SENSOR_BED != 0)
    #if HEATER_BED_RAW_LO_TEMP > HEATER_BED_RAW_HI_TEMP
        if(current_temperature_bed_raw <= bed_maxttemp_raw) {
    #else
        if(current_temperature_bed_raw >= bed_maxttemp_raw) {
    #endif
            target_temperature_bed = 0;
            bed_max_temp_error();
        }
#endif

// }

#ifdef BABYSTEPPING
    for(uint8_t axis=0;axis<3;axis++) {
        int curTodo=babystepsTodo[axis]; //get rid of volatile for performance
        if(curTodo>0) {
            babystep(axis,/*fwd*/true);
            babystepsTodo[axis]--; //less to do next time
        }
        else if(curTodo<0) {
            babystep(axis,/*fwd*/false);
            babystepsTodo[axis]++; //less to do next time
        }
    }
#endif //BABYSTEPPING

}

ifdef PIDTEMP

// 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; }

AlexeyKruglov commented 10 years ago

This line

if (isr_soft_pwm[i] < pwm_count) digitalWrite(e_pins[i][HEATER_PIN],0);

should be outside if(pwm_count == 0) block, not inside.

By the way, it's better to use <= instead of < here, see explanation in this commit: https://github.com/AlexeyKruglov/Marlin/commit/d4427ee55f26a11044eb2a3362f465bc4980a033

PatONeil commented 10 years ago

Alexey,

Thanks again for your time to look at the code. If you want the .h file, let me know.

Pat

From: Alexey Kruglov Sent: Wednesday, July 09, 2014 3:00 AM To: ErikZalm/Marlin Cc: PatONeil Subject: Re: [Marlin] Multiple extruders (6) with temperature.cpp (#995)

This line

if (isr_soft_pwm[i] < pwm_count) digitalWrite(e_pins[i][HEATER_PIN],0); should be outside if(pwm_count == 0) block, not inside.

By the way, it's better to use <= instead of < here, see explanation in this commit: AlexeyKruglov@d4427ee

— Reply to this email directly or view it on GitHub.

boelle commented 9 years ago

was this one solved?

boelle commented 9 years ago

please open a new issue if this is still present in the current bug fixing branch

https://github.com/ErikZalm/Marlin/tree/Marlin-v1-bug-fixing

github-actions[bot] commented 2 years ago

This issue has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.