Want to add count down timer to a PID controlled heater with PT100

Hi,
This is my first project and I managed to up and running a PID controlled heater with PT100(After two weeks research and reading thousands of topics :)). Now i want to add a countdown timer to it. I can set a “SET TIME” using upPin and downPin and I connected a push button to pin 9 named “tpin”. When i press this push button, I wanted a timer to start from the “SET TIME” and count down to zero and stop( for eg. if i set the SET TIME as 50 minutes, when I press "tPin’, the display should start the count down like 50:00, 49:59, 49:58…0:00 and I want a buzzer to start). I tried several methods but all are failed:(. I read hundreds of topics and nothing helping me to achieve this. Can anybody show me the right track. Any inputs will be highly appreciated. Thanks in advance… Please find the full code below

#include <PID_v1.h>
#include <EEPROM.h>
#include “RTDModule.h”
RTDModule rtd;
double TEMP;
const int buzzerPin = 13;
const int upPin = 8;
const int tPin = 9;
const int downPin = 7;
int buttonState = 0;
double Setpoint2;
int AT;
double Setpoint1, Input, Output;
unsigned long lasttime ;

////////////////////////////////////////////////////////////////////////////////////////
// PID ADJUST
/////////////////////////////////////////////////////////////////////////////////////////

double aggKp=15, aggKi=.5, aggKd=.2;
double consKp=2, consKi=.25, consKd=.2;
//////////////////////////////////////////////////////////////////////////////////////////
PID myPID(&Input, &Output, &Setpoint1, consKp, consKi, consKd, DIRECT);
////////////////////////////////////////////////////////////////////////////////////////
// SETUP
//////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
AT=Setpoint2*60000;
Serial.begin(9600);
Input = (TEMP);
pinMode (0, INPUT);

/////////////////////////////////////////////////////////////////////////////////////////////
// PT-100 Calibration Values
////////////////////////////////////// //////////////////////////////////////////////////////

rtd.calibration(0, 0.10647, -3.194);

////////////////////////////////////// //////////////////////////////////////////////////////

Setpoint1 = EEPROM.read(0);
Setpoint2 = EEPROM.read(1);
analogReference(INTERNAL);
myPID.SetMode(AUTOMATIC);
}
void loop()
{
TEMP = digitalLowPass(TEMP, rtd.getTemperature(0) ,0.90);
Input = (TEMP);
double gap = abs(Setpoint1-Input);
if(gap<2)
{
myPID.SetTunings(consKp, consKi, consKd);
}
else
{
myPID.SetTunings(aggKp, aggKi, aggKd);
}
myPID.Compute();
analogWrite(6,Output);
////////////////////////////////////////////////////////////////////////////////////////////
// BUTTON FUNCTIONS
///////////////////////////////////////////////////////////////////////////////////////////

{

if(digitalRead(tPin)==HIGH)
{
Setpoint2+=1;
/////////////////////////////////////////////////////////////////////////////////////////////
// Setpoint1 ADJUST UP PIN2
////////////////////////////////////// //////////////////////////////////////////////////////
//////////////////
//////////////////
Setpoint2 = constrain(Setpoint2, 0, 99);
}
/////////////////////////////////////////////////////////////////////////////////////////////
EEPROM.write(1,Setpoint2);

if(digitalRead(upPin)==HIGH)
{
Setpoint1+=1;
/////////////////////////////////////////////////////////////////////////////////////////////
// Setpoint1 ADJUST UP PIN
////////////////////////////////////// //////////////////////////////////////////////////////
//////////////////
//////////////////
Setpoint1 = constrain(Setpoint1, 0, 90);
}
/////////////////////////////////////////////////////////////////////////////////////////////
EEPROM.write(0,Setpoint1);
//////////////////
if(digitalRead(downPin)==HIGH)
{
/////////////////////////////////////////////////////////////////////////////////////////////
// Setpoint1 ADJUST DOWNPIN
////////////////////////////////////// //////////////////////////////////////////////////////
Setpoint1-=1;
Setpoint1 = constrain(Setpoint1, 0, 90);
}
/////////////////////////////////////////////////////////////////////////////////////////////

{
if (AT<0); // How i make a timer here? When i put this code, it just started counting backfrom 0… :frowning:

{
AT-=1 ;

}}

/////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////
// PRINT SERIAL

/////////////////////////////////////////////////////////////////////////////////////////////

Serial.println("");
Serial.println(AT);
delay(100);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// FILTER

/////////////////////////////////////////////////////////////////////////////////////////////////

double digitalLowPass(double last_smoothed, double new_value, double filterVal)
{
double smoothed = (new_value * (1 - filterVal)) + (last_smoothed * filterVal);
return smoothed;
}

Now i want to add a countdown timer

To count down to what? I can't see where a delay between deciding that a change is needed, and actually making that change, is in keeping with the PID philosophy.

Dear Pauls, Thank you for your response. I am sorry if my question was not clear. Actually my PID controlled heater is working fine. For the project, it requires that after the set temperature reached, user has to put some samples on the heater and keep it on for 10 minutes(some times up to 99 minutes). After that ten minutes, there should be a buzzer sound alerting the user that the process is over and can switch off the heater. If I press a push button(buzzerPin), I want the actual time to count down to zero from the set temperature. Presently I don't have any idea how to achieve that... Hope all are clear. Please let me know if you want to know anything else..

If I press a push button(buzzerPin), I want the actual time to count down to zero from the set temperature.

What is connected to the buzzerPin? What is the buzzer connected to? Why isn't the buzzer connected to the buzzerPin and the switch connected to the switchPin?

Once the state of the switch is determined to have transitioned to pressed (see the state change detection example), use millis() to record when that happens.

On each pass through loop(), compare now (using millis()) to then, and compare then to 0. If then is not zero and now minus then is greater than or equal to the needed interval, buzz away.

Dear Pols, Sorry, I didn't get it correctly. In fact I got an electronics background and don't even know the ABCD of the programming language. I am studying through examples, but sometimes most of the things are hard to digest :( I am just pasting the current modified sketch, I made the changes as you suggested/ Can you point out the mistake in the new sketch since it is not working as I think :(

arduinofankerala: Can you point out the mistake in the new sketch since it is not working as I think :(

Not unless you post the new code properly. And elaborate on what "not working" means (Hint: It's working, just no how you want it to. You need to explain both how it's working, and how you are expecting it to work)

Dear Pols, Sorry, I didn't get it correctly. In fact I got an electronics background and don't even know the ABCD of the programming language. I am studying through examples, but sometimes most of the things are hard to digest :( I am just pasting the current modified sketch, I made the changes as you suggested/ Can you point out the mistake in the new sketch since it is not working (instead of counting from my set point to zero, it just showing zero" (When pasting for the forum, there was an error last time :( ) since the message exceeds the limit I am posting sketch as another post

#include <PID_v1.h>
#include <EEPROM.h>
#include “RTDModule.h”
RTDModule rtd;
double TEMP;
const int timerstartPin = 9;
const int upPin = 8;
const int tPin = 1;
const int downPin = 7;
const int buzzerPin = 13;
int buttonState = 0;
int lastButtonState = 0;
double Setpoint2;
int ST;
double Setpoint1, Input, Output;
unsigned long lasttime ;
unsigned long start;

////////////////////////////////////////////////////////////////////////////////////////
// PID ADJUST
/////////////////////////////////////////////////////////////////////////////////////////

double aggKp=15, aggKi=.5, aggKd=.2;
double consKp=2, consKi=.25, consKd=.2;
//////////////////////////////////////////////////////////////////////////////////////////
PID myPID(&Input, &Output, &Setpoint1, consKp, consKi, consKd, DIRECT);
////////////////////////////////////////////////////////////////////////////////////////
// SETUP
//////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
ST=Setpoint2*60000;
Serial.begin(9600);
Input = (TEMP);
pinMode (0, INPUT);
pinMode(timerstartPin, INPUT);
pinMode(buzzerPin, OUTPUT);

/////////////////////////////////////////////////////////////////////////////////////////////
// PT-100 Calibration Values
////////////////////////////////////// //////////////////////////////////////////////////////

rtd.calibration(0, 0.10647, -3.194);

////////////////////////////////////// //////////////////////////////////////////////////////

Setpoint1 = EEPROM.read(0);
Setpoint2 = EEPROM.read(1);
analogReference(INTERNAL);
myPID.SetMode(AUTOMATIC);
}
void loop()
{

buttonState = digitalRead(timerstartPin);

if (buttonState != lastButtonState)
{
if (buttonState == HIGH)
{ start= millis();
} }
if (start = ST)
{
digitalWrite(buzzerPin, HIGH);
}

else
{
digitalWrite(buzzerPin, LOW);
}
lastButtonState = buttonState;

TEMP = digitalLowPass(TEMP, rtd.getTemperature(0) ,0.90);
Input = (TEMP);
double gap = abs(Setpoint1-Input);
if(gap<2)
{
myPID.SetTunings(consKp, consKi, consKd);
}
else
{
myPID.SetTunings(aggKp, aggKi, aggKd);
}
myPID.Compute();
analogWrite(6,Output);
////////////////////////////////////////////////////////////////////////////////////////////
// BUTTON FUNCTIONS
///////////////////////////////////////////////////////////////////////////////////////////

{

if(digitalRead(tPin)==HIGH)
{
Setpoint2+=1;
/////////////////////////////////////////////////////////////////////////////////////////////
// Setpoint1 ADJUST UP PIN2
////////////////////////////////////// //////////////////////////////////////////////////////
//////////////////
//////////////////
Setpoint2 = constrain(Setpoint2, 0, 99);
}
/////////////////////////////////////////////////////////////////////////////////////////////
EEPROM.write(1,Setpoint2);

if(digitalRead(upPin)==HIGH)
{
Setpoint1+=1;
/////////////////////////////////////////////////////////////////////////////////////////////
// Setpoint1 ADJUST UP PIN
////////////////////////////////////// //////////////////////////////////////////////////////
//////////////////
//////////////////
Setpoint1 = constrain(Setpoint1, 0, 90);
}
/////////////////////////////////////////////////////////////////////////////////////////////
EEPROM.write(0,Setpoint1);
//////////////////
if(digitalRead(downPin)==HIGH)
{
/////////////////////////////////////////////////////////////////////////////////////////////
// Setpoint1 ADJUST DOWNPIN
////////////////////////////////////// //////////////////////////////////////////////////////
Setpoint1-=1;
Setpoint1 = constrain(Setpoint1, 0, 90);
}
/////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////
// PRINT SERIAL

/////////////////////////////////////////////////////////////////////////////////////////////

Serial.println("");
Serial.println(start);
delay(100);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// FILTER

/////////////////////////////////////////////////////////////////////////////////////////////////

double digitalLowPass(double last_smoothed, double new_value, double filterVal)
{
double smoothed = (new_value * (1 - filterVal)) + (last_smoothed * filterVal);
return smoothed;
}

I see we’re going to continue to not post the code properly, then? I put the link in my post for a reason. So that you would read it, and perhaps notice that you should be NOT using the “copy to forums” option, and instead, using CODE tags.

Oh! really sorry…

This is my code…

#include <PID_v1.h>
#include <EEPROM.h>
#include "RTDModule.h"
RTDModule rtd;
double TEMP;
const int timerPin = 9;  
const int upPin = 1;  
const int tPin = 8;  
const int downPin = 7;
const int buzzerPin = 13;
int buttonsetTimeate = 0; 
int lasetTimeButtonsetTimeate = 0;
double Setpoint2;
int setTime;
double Setpoint1, Input, Output;
unsigned long lasetTimetime ;
unsigned long setTimeartTime;
unsigned long elapsedTime;


////////////////////////////////////////////////////////////////////////////////////////
//                                  PID ADJUsetTime
/////////////////////////////////////////////////////////////////////////////////////////

double aggKp=15, aggKi=.5, aggKd=.2;
double consKp=2, consKi=.25, consKd=.2;
//////////////////////////////////////////////////////////////////////////////////////////
PID myPID(&Input, &Output, &Setpoint1, consKp, consKi, consKd, DIRECT);
////////////////////////////////////////////////////////////////////////////////////////
//                                  SETUP
//////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
  setTime=Setpoint2*60000;
  Serial.begin(9600); 
  Input = (TEMP);  
  pinMode (0, INPUT);  
  pinMode(timerPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
 
  /////////////////////////////////////////////////////////////////////////////////////////////
  //                            PT-100  Calibration Values
  ////////////////////////////////////// //////////////////////////////////////////////////////

  rtd.calibration(0, 0.10647, -3.194);       

  ////////////////////////////////////// //////////////////////////////////////////////////////

  Setpoint1 = EEPROM.read(0);
  Setpoint2 = EEPROM.read(1);
  analogReference(INTERNAL);  
  myPID.SetMode(AUTOMATIC);
}
void loop()
{
  
buttonsetTimeate = digitalRead(timerPin);

  if (buttonsetTimeate != lasetTimeButtonsetTimeate) 
  {
    if (buttonsetTimeate == HIGH)
     { setTimeartTime= millis();       
     } }
     
  elapsedTime =   millis() - setTimeartTime;   
     
    if  (elapsedTime = setTime)
      { 
          digitalWrite(buzzerPin, HIGH);          
  }
  
  else 
  {
   digitalWrite(buzzerPin, LOW);
  }
  lasetTimeButtonsetTimeate = buttonsetTimeate;  
 

  
  TEMP = digitalLowPass(TEMP, rtd.getTemperature(0) ,0.90);  
  Input = (TEMP);
  double gap = abs(Setpoint1-Input);
  if(gap<2)    
  {  
    myPID.SetTunings(consKp, consKi, consKd);
  }
  else
  {
    myPID.SetTunings(aggKp, aggKi, aggKd);
  }
  myPID.Compute();
  analogWrite(6,Output);  
  ////////////////////////////////////////////////////////////////////////////////////////////
  //                                         BUTTON FUNCTIONS
  ///////////////////////////////////////////////////////////////////////////////////////////
 
  {   
                                                                             
    if(digitalRead(tPin)==HIGH)                                             
    {                                                                         
      Setpoint2+=1;                                                              
      /////////////////////////////////////////////////////////////////////////////////////////////
      //                                 Setpoint1 ADJUsetTime UP PIN2
      ////////////////////////////////////// //////////////////////////////////////////////////////
      ////////////////// 
      ////////////////// 
      Setpoint2 = constrain(Setpoint2, 0, 99);               
    }                                                                           
    /////////////////////////////////////////////////////////////////////////////////////////////
    EEPROM.write(1,Setpoint2);                                                 


    if(digitalRead(upPin)==HIGH)                                              
    {                                                                        
      Setpoint1+=1;                                                             
      /////////////////////////////////////////////////////////////////////////////////////////////
      //                                 Setpoint1 ADJUsetTime UP PIN
      ////////////////////////////////////// //////////////////////////////////////////////////////
      ////////////////// 
      ////////////////// 
      Setpoint1 = constrain(Setpoint1, 0, 90);               
    }                                                                           
    /////////////////////////////////////////////////////////////////////////////////////////////
    EEPROM.write(0,Setpoint1);                                               
    ////////////////// 
    if(digitalRead(downPin)==HIGH)                                           
    {                                                                        
      /////////////////////////////////////////////////////////////////////////////////////////////
      //                                 Setpoint1 ADJUsetTime DOWNPIN
      ////////////////////////////////////// //////////////////////////////////////////////////////
      Setpoint1-=1;                                                              
      Setpoint1 = constrain(Setpoint1, 0, 90);       
    }                                                                          
    /////////////////////////////////////////////////////////////////////////////////////////////







    /////////////////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////////////////
    //                                      PRINT SERIAL

    ///////////////////////////////////////////////////////////////////////////////////////////// 


    Serial.println("");
    Serial.println(setTime);
   delay(100);
  }           
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//                                              FILTER

/////////////////////////////////////////////////////////////////////////////////////////////////

double digitalLowPass(double last_smoothed, double new_value, double filterVal)
{
  double smoothed = (new_value * (1 - filterVal)) + (last_smoothed * filterVal);
  return smoothed;
}
    if  (elapsedTime = setTime)

==?

    if (buttonsetTimeate == HIGH)
     { setTimeartTime= millis();       
     } }

I'm in formatting hell. If you don't know how to format the code properly, put each '}' and '{' on THEIR OWN lines, and use Tools > Auto Format in the Arduino IDE.

You are correct. I changed it now.. now display showing elapsed time even before i press the start button(timerPin). What I am doing wrong?

arduinofankerala: What I am doing wrong?

Not posting updated code when you make changes.

Again sorry :frowning:

Please find updated code below. Now I am getting the elapsed time in seconds in the serial. But it starts even before i press the timerPin… What I am doing wrong?

#include <PID_v1.h>
#include <EEPROM.h>
#include "RTDModule.h"
RTDModule rtd;
double TEMP;
const int timerPin = 9;  
const int upPin = 1;  
const int tPin = 8;  
const int downPin = 7;
const int buzzerPin = 13;
int buttonState = 0; 
int lastButtonState = 0;
double Setpoint2;
int setTime;

double Setpoint1, Input, Output;
unsigned long lasttime ;
unsigned long startTime;
unsigned long elapsedTime ; 

////////////////////////////////////////////////////////////////////////////////////////
//                                  PID ADJUsetTime
/////////////////////////////////////////////////////////////////////////////////////////

double aggKp=15, aggKi=.5, aggKd=.2;
double consKp=2, consKi=.25, consKd=.2;
//////////////////////////////////////////////////////////////////////////////////////////
PID myPID(&Input, &Output, &Setpoint1, consKp, consKi, consKd, DIRECT);
////////////////////////////////////////////////////////////////////////////////////////
//                                  SETUP
//////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
  setTime=Setpoint2*60000;
  Serial.begin(9600); 
  Input = (TEMP);  
  pinMode (0, INPUT);  
  pinMode(timerPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
 
  /////////////////////////////////////////////////////////////////////////////////////////////
  //                            PT-100  Calibration Values
  ////////////////////////////////////// //////////////////////////////////////////////////////

  rtd.calibration(0, 0.10647, -3.194);       

  ////////////////////////////////////// //////////////////////////////////////////////////////

  Setpoint1 = EEPROM.read(0);
  Setpoint2 = EEPROM.read(1);
  analogReference(INTERNAL);  
  myPID.SetMode(AUTOMATIC);
}
void loop()
{

  buttonState = digitalRead(timerPin);

  if (buttonState != lastButtonState) 
  {    
    if (buttonState == HIGH)
    { 
      startTime= millis();  
    } 
  }

  elapsedTime =   millis() - startTime;   

  if  (elapsedTime == setTime)
  { 
    digitalWrite(buzzerPin, HIGH);  
  }

  else 
  {   
    digitalWrite(buzzerPin, LOW);  
  }
  lastButtonState = buttonState;  


  
  TEMP = digitalLowPass(TEMP, rtd.getTemperature(0) ,0.90);  
  Input = (TEMP);
  double gap = abs(Setpoint1-Input);
  if(gap<2)    
  {  
    myPID.SetTunings(consKp, consKi, consKd);
  }
  else
  {
    myPID.SetTunings(aggKp, aggKi, aggKd);
  }
  myPID.Compute();
  analogWrite(6,Output);  
  ////////////////////////////////////////////////////////////////////////////////////////////
  //                                         BUTTON FUNCTIONS
  ///////////////////////////////////////////////////////////////////////////////////////////
 
  {   
                                                                             
    if(digitalRead(tPin)==HIGH)                                             
    {                                                                         
      Setpoint2+=1;                                                              
      /////////////////////////////////////////////////////////////////////////////////////////////
      //                                 Setpoint1 ADJUsetTime UP PIN2
      ////////////////////////////////////// //////////////////////////////////////////////////////
      ////////////////// 
      ////////////////// 
      Setpoint2 = constrain(Setpoint2, 0, 99);               
    }                                                                           
    /////////////////////////////////////////////////////////////////////////////////////////////
    EEPROM.write(1,Setpoint2);                                                 


    if(digitalRead(upPin)==HIGH)                                              
    {                                                                        
      Setpoint1+=1;                                                             
      /////////////////////////////////////////////////////////////////////////////////////////////
      //                                 Setpoint1 ADJUsetTime UP PIN
      ////////////////////////////////////// //////////////////////////////////////////////////////
      ////////////////// 
      ////////////////// 
      Setpoint1 = constrain(Setpoint1, 0, 90);               
    }                                                                           
    /////////////////////////////////////////////////////////////////////////////////////////////
    EEPROM.write(0,Setpoint1);                                               
    ////////////////// 
    if(digitalRead(downPin)==HIGH)                                           
    {                                                                        
      /////////////////////////////////////////////////////////////////////////////////////////////
      //                                 Setpoint1 ADJUsetTime DOWNPIN
      ////////////////////////////////////// //////////////////////////////////////////////////////
      Setpoint1-=1;                                                              
      Setpoint1 = constrain(Setpoint1, 0, 90);       
    }                                                                          
    /////////////////////////////////////////////////////////////////////////////////////////////

    /////////////////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////////////////
    //                                      PRINT SERIAL

    ///////////////////////////////////////////////////////////////////////////////////////////// 


    Serial.println("");
    Serial.println(setTime);
   Serial.println("");
    Serial.println(elapsedTime/1000);
   delay(100);
  }           
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//                                              FILTER

/////////////////////////////////////////////////////////////////////////////////////////////////

double digitalLowPass(double last_smoothed, double new_value, double filterVal)
{
  double smoothed = (new_value * (1 - filterVal)) + (last_smoothed * filterVal);
  return smoothed;
}

Removing all the unrelated code:

unsigned long lasttime ;
unsigned long startTime;
unsigned long elapsedTime ; 
...
void loop()
{
  ...
  elapsedTime =   millis() - startTime;   

    Serial.println(elapsedTime/1000);
  ...      
}

We can see that there is nothing preventing the Serial.print from occuring. All you are doing now with the timerPin, is updating startTime, which will change the result printed, but not the fact that it's printed. If you don't want it to display until you've hit the button, you need some sort of flag variable that is set when the button is pushed, cleared when you want to stop printing the value, and checked to be true, before you print the value.

}
void loop()
{

  buttonState = digitalRead(timerPin);

You still have formatting issues that YOU need to fix. Use white space BETWEEN functions, not at the start of a function.

First of all, I hope now my code is as per the suggestion of Pauls. Before Arrch made his valuable suggestion, somehow I figured out that the elapsedTime =   millis() - startTime;command because of the help of printing all the values to Serial and analysing. So I figured out that if I make a statement like elapsedTime =  Setpoint2*60000 - (millis())    ; [Setpoint is the value I needed in minutes, so Converted by multiplying by 60000. The setpoint value I am keeping in the Setpoint2 = EEPROM.read(1); by the help of the Setpoint up and down buttons. In void setup() I ceated a command like setTime= Setpoint2*60000; and try to give in the void Loop() elapsedTime =  setTime - (millis()) instead of elapsedTime =  Setpoint2*60000 - (millis()) , But strangly its not working!] I am getting an elapsed counter which starting from the setpoint maximum in seconds( for eg. if my Setpoint=1minute, then the display counting down from 59,58,57 up to 00(still there is a third digit I am thinking how to avoid). Everything is perfect except three things

1) When I press the timerPin, then only the count down should start, now the countdown starting once the sketch reaches Arduino. After several examles by Pauls and Arrch I couldnt figured it out(Sorry, very new to this and I am little slow in maths and reading simbols and signs, please bear with me :) 2)Even after I made a command

  if  (elapsedTime == 0)
  { 
    digitalWrite(buzzerPin, HIGH);  
 }
  else 
  {   
    digitalWrite(buzzerPin, LOW);

The LED is not glowing. The same button Pin and LED i checked with "Button Example " and made sure working OK. 3) After the elapsed "Set time" the display showing very high value in seconds( I read that that s the value Arduino can count, about 50 days) instead of staying in 0.00. I also like the elapsed time to be showed like HH:MM:SS (Any related example)

So this are the three last issues I am facing . Unfortunately even after 12 hours of continues searching and trial and errors I couldn't figured it out. So I hope Pauls or Arrch can point out my mistakes... By the mean time I am still trying... Please find the current working as described code in next post

Last code…(Added an LCD :))…

#include <LiquidCrystal.h>      
#include <PID_v1.h>
#include <EEPROM.h>
#include "RTDModule.h"
RTDModule rtd;
double TEMP;
const int timerPin = 9;  
const int upPin = 1;  
const int tPin = 8;  
const int downPin = 7;
const int buzzerPin = 13;
int calibrationValue; 
int buttonState = 0; 
int lastButtonState = 0;
double Setpoint2;
int setTime;
double Setpoint1, Input, Output;
unsigned long lasttime ;
unsigned long startTime;
unsigned long elapsedTime ;
////////////////////////////////////////////////////////////////////////////////////////
//                                  PID ADJUST
/////////////////////////////////////////////////////////////////////////////////////////

double aggKp=15, aggKi=.5, aggKd=.2;
double consKp=2, consKi=.25, consKd=.2;
//////////////////////////////////////////////////////////////////////////////////////////
PID myPID(&Input, &Output, &Setpoint1, consKp, consKi, consKd, DIRECT);
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 
////////////////////////////////////////////////////////////////////////////////////////
//                                  SETUP
//////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
  setTime= Setpoint2*60000;
  Serial.begin(9600); 
  lcd.begin(16, 2);  
  lcd.setCursor(0, 0);                                           
  lcd.print("HEATER With PID & PT100");                                     
  lcd.clear(); 
  Input = (TEMP);  
  pinMode (0, INPUT);  
  pinMode(timerPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  /////////////////////////////////////////////////////////////////////////////////////////////
  //                            PT-100  Calibration Values
  ////////////////////////////////////// //////////////////////////////////////////////////////

  rtd.calibration(0, 0.10647, -3.194);       

  ////////////////////////////////////// //////////////////////////////////////////////////////
  Setpoint1 = EEPROM.read(0);
  Setpoint2 = EEPROM.read(1);
  analogReference(INTERNAL);  
  myPID.SetMode(AUTOMATIC);
}
void loop()
    { 
    elapsedTime =   millis() - startTime; 
    Serial.println(elapsedTime/1000);
    if (timerPin == HIGH);
    { 
      startTime= millis();  
    }
    elapsedTime =  Setpoint2*60000 - (millis())    ; 
  if  (elapsedTime == 0)
  { 
    digitalWrite(buzzerPin, HIGH);  
 }
  else 
  {   
    digitalWrite(buzzerPin, LOW);  
  }
  TEMP = digitalLowPass(TEMP, rtd.getTemperature(0) ,0.90);  
  Input = (TEMP);
  double gap = abs(Setpoint1-Input);
  if(gap<2)    
  {  
    myPID.SetTunings(consKp, consKi, consKd);
  }
  else
  {
    myPID.SetTunings(aggKp, aggKi, aggKd);
  }
  myPID.Compute();
  analogWrite(6,Output);  
  ////////////////////////////////////////////////////////////////////////////////////////////
  //                                         BUTTON FUNCTIONS
  ///////////////////////////////////////////////////////////////////////////////////////////
  {   
    if(digitalRead(tPin)==HIGH)                                            
   {                                                                             ////////////////// 
      Setpoint2+=1;                                                              //////////////////
      /////////////////////////////////////////////////////////////////////////////////////////////
      //                                 Setpoint1 ADJUST UP PIN2
      ////////////////////////////////////// //////////////////////////////////////////////////////
      Setpoint2 = constrain(Setpoint2, 0, 99);               
    }                                                                         
    /////////////////////////////////////////////////////////////////////////////////////////////
    EEPROM.write(1,Setpoint2);    
    if(digitalRead(upPin)==HIGH)                                              ////////////////// 
    {                                                                         ////////////////// 
      Setpoint1+=1;                                                              //////////////////
      /////////////////////////////////////////////////////////////////////////////////////////////
      //                                 Setpoint1 ADJUST UP PIN
      ////////////////////////////////////// //////////////////////////////////////////////////////
      Setpoint1 = constrain(Setpoint1, 0, 90);               
    }                                                                          
    /////////////////////////////////////////////////////////////////////////////////////////////
    EEPROM.write(0,Setpoint1);                                                  ////////////////// 
    ////////////////// 
    if(digitalRead(downPin)==HIGH)                                             ////////////////// 
    {                                                                        
      /////////////////////////////////////////////////////////////////////////////////////////////
      //                                 Setpoint1 ADJUST DOWNPIN
      ////////////////////////////////////// //////////////////////////////////////////////////////
      Setpoint1-=1;                                                               
      Setpoint1 = constrain(Setpoint1, 0, 90);        
    }  
    /////////////////////////////////////////////////////////////////////////////////////////////
    //                                       PRINT LCD

    ///////////////////////////////////////////////////////////////////////////////////////////// 
    Serial.println("setTime");
     Serial.println(setTime);
    Serial.println("elapsedTime");
    Serial.println(elapsedTime/100);
    Serial.println("startTime");
    Serial.println(startTime/1000);
    lcd.setCursor(0, 0);                                          
    lcd.print("ST= ");                                   
    lcd.setCursor(3, 0);                                          
    lcd.print(Setpoint1); 
    lcd.setCursor(7, 0);  
    lcd.print((char)223);
    lcd.setCursor(8,0);
    lcd.print("C");
    lcd.setCursor(0, 1);                                          
    lcd.print("AT= ");                                   
    lcd.setCursor(3, 1);                                         
    lcd.print(TEMP);
    lcd.setCursor(7, 1);  
    lcd.print((char)223);
    lcd.setCursor(8,1);
    lcd.print("C"); 
    lcd.setCursor(10, 0);                                          
    lcd.print("ST=");                                   
    lcd.setCursor(13, 0);                                          
    lcd.print(Setpoint2); 
    lcd.setCursor(15,0);
    lcd.print("m");
    lcd.setCursor(10, 1); 
    lcd.setCursor(10, 1);                                         
    lcd.print(elapsedTime/1000);
    delay(1000);
  }           
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//                                              FILTER
/////////////////////////////////////////////////////////////////////////////////////////////////
double digitalLowPass(double last_smoothed, double new_value, double filterVal)
{
  double smoothed = (new_value * (1 - filterVal)) + (last_smoothed * filterVal);
  return smoothed;
}

Please find the result from Serial print for one minute..

SetTime
0
elapsedTime
42949546
s0
setTime
0
elapsedTime
598
startTime
0
1
setTime
0
elapsedTime
588
startTime
1
1
setTime
0
elapsedTime
578
startTime
2
1
setTime
0
elapsedTime
568
startTime
3
1
setTime
0
elapsedTime
558
startTime
4
1
setTime
0
elapsedTime
548
startTime
5
1
setTime
0
elapsedTime
538
startTime
6
1
setTime
0
elapsedTime
528
startTime
7
1
setTime
0
elapsedTime
518
startTime
8
1
setTime
0
elapsedTime
507
startTime
9
1
setTime
0
elapsedTime
497
startTime
10
1
setTime
0
elapsedTime
487
startTime
11
1
setTime
0
elapsedTime
477
startTime
12
1
setTime
0
elapsedTime
467
startTime
13
1
setTime
0
elapsedTime
457
startTime
14
1
setTime
0
elapsedTime
447
startTime
15
1
setTime
0
elapsedTime
437
startTime
16
1
setTime
0
elapsedTime
427
startTime
17
1
setTime
0
elapsedTime
417
startTime
18
1
setTime
0
elapsedTime
406
startTime
19
1
setTime
0
elapsedTime
396
startTime
20
1
setTime
0
elapsedTime
386
startTime
21
1
setTime
0
elapsedTime
376
startTime
22
1
setTime
0
elapsedTime
366
startTime
23
1
setTime
0
elapsedTime
356
startTime
24
1
setTime
0
elapsedTime
346
startTime
25
1
setTime
0
elapsedTime
336
startTime
26
1
setTime
0
elapsedTime
326
startTime
27
1
setTime
0
elapsedTime
316
startTime
28
1
setTime
0
elapsedTime
305
startTime
29
1
setTime
0
elapsedTime
295
startTime
30
1
setTime
0
elapsedTime
285
startTime
31
1
setTime
0
elapsedTime
275
startTime
32
1
setTime
0
elapsedTime
265
startTime
33
1
setTime
0
elapsedTime
255
startTime
34
1
setTime
0
elapsedTime
245
startTime
35
1
setTime
0
elapsedTime
235
startTime
36
1
setTime
0
elapsedTime
225
startTime
37
1
setTime
0
elapsedTime
215
startTime
38
1
setTime
0
elapsedTime
204
startTime
39
1
setTime
0
elapsedTime
194
startTime
40
1
setTime
0
elapsedTime
184
startTime
41
1
setTime
0
elapsedTime
174
startTime
42
1
setTime
0
elapsedTime
164
startTime
43
1
setTime
0
elapsedTime
154
startTime
44
1
setTime
0
elapsedTime
144
startTime
45
1
setTime
0
elapsedTime
134
startTime
46
1
setTime
0
elapsedTime
124
startTime
47
1
setTime
0
elapsedTime
114
startTime
48
1
setTime
0
elapsedTime
103
startTime
49
1
setTime
0
elapsedTime
93
startTime
50
1
setTime
0
elapsedTime
83
startTime
51
1
setTime
0
elapsedTime
73
startTime
52
1
setTime
0
elapsedTime
63
startTime
53
1
setTime
0
elapsedTime
53
startTime
54
1
setTime
0
elapsedTime
43
startTime
55
1
setTime
0
elapsedTime
33
startTime
56
1
setTime
0
elapsedTime
23
startTime
57
1
setTime
0
elapsedTime
13
startTime
58
1
setTime
0
elapsedTime
2
startTime
59
1
setTime
0
elapsedTime
42949665
startTime
60
1
setTime
0
elapsedTime
42949655
startTime
61
1
setTime
0
elapsedTime
42949645
startTime
62
1
setTime
0
elapsedTime
42949635
startTime
63
1
setTime
0
elapsedTime
42949625
startTime
64
1
setTime
0
elapsedTime
42949615
startTime
65