//Memoria dati
#include <EEPROM.h>
//------------
int tempf = 0;
int tempc = 0;
int buttonstatea = 0;  //Variabile per leggere stato pulsante accensione
int buttonstatev = 0;  //Variabile per lettura stato pulsante vapore
int buttonstateok = 0;
int modeblink = 0;  //Variabile per lampeggio turbo
int ledstate = 0;   //Variabile per lampeggio di stato
int timeravvio = 0;
//Ciclo primo avvio Pompa
unsigned long contatore;
unsigned long contaimpulsi;   // timer avvio a freddo
unsigned long contaimpulsi1;  //timer avvio a caldo
int controlpump = 0;          //usato per caldaia fredda
int controlpump1 = 0;         //usato per caldaia calda
int pumpCont = 0;
int pumpState = 0;
int timepump = 0;
int memtemp = 0;  //PER AVVIO CALDAIA A FREDDO
int pump1 = LOW;
int memon = 0;
int memon1 = 0;
int memton = 0;
int memokon = 0;
int valbuttonold = 0;
int valbuttontold = 0;
int valbuttonokold = 0;
int loadh2o = 0;
int hotstart = 0;
// POMPA
int surepumptemp = 0;
int buttonstateh2o = 0;
int memh2o = 0;

//
int H2OCont = 0;
int H2Omillis = 0;
int h2o = 0;
int buttonstatet = 0;
int heatingerror = 0;
int error = 0;
int errorh2o = 0;
//PULIZIA
int memclean = 0;
int cleantime = 0;
int pumpa = 0;
int pumpb = 0;
int pumpon = 0;
int cleandelay = 0;
int cleanon = 0;
int stop4clean = 0;

//PROGRAMMI
int A;
int B;
int C;
int Df;
int tfeco = 300;    //350 stirato zia andava bene, 200 NON BRUCIA TAPPETO
int tfturbo = 200;  //200 fin troppo blando

int tminECO = 5;   //  sembra perfetto
int tmaxECO = 40;  // 46 troppo alto, 44 PROVATO con mamma ma non va bene poco vapore 42. 42 RIMANE SENZA VAPORE.
int tECO = 30;     //sembra perfetto. abbassato a 30 perchè 35 faceva 1 po di acqua.
//turbo provato con mamma, sembrava andare ok

int tminTURBO = 5;   //a 12 la pompa non è da avviare. Non riesce a caricare
int tmaxTURBO = 32;  // provo 32, troppa h20! USARE SOLO QUESTO PARAMETRO PER CARICO! quando l'acqua scarseggia, la temp rimane alta
int tTURBO = 18;     // 17 vapore molto forte, è A FILO L'INTERVENTO DELLA SICUREZZA, SI SENTE LEGGERO SFIATO.


//millis1 Caldaia
unsigned long previousMillis1 = 0;  // memorizza l'ultimo stato
unsigned long interval1 = 1000;     //intervallo di lettura NTC ferro
//millis2 Ferro
unsigned long previousMillis2 = 0;
unsigned long interval2 = 1000;  //intervallo di lettura NTC caldaia
//millis3 TIMER USO CALDAIA
unsigned long previousMillis3 = 0;
unsigned long interval3 = 5000;
//in un ora ci sono 3600s. 5ore di uso ferro sono 18000s. Variabili ammesse nella eeprom 0-255. Suddiviso 18000s secondi nei 255 ammissibili.
//18000/255 =71s. ogni 71 sec incremento la variabile nella eeprom.
//millis4 POMPA  Secondi di funzionamento pompa
unsigned long previousMillis4 = 0;
unsigned long interval4 = 4000;
//millis5 X TEMPORIZZATORE PRIMO AVVIO CALDAIA CALDA
unsigned long previousMillis5 = 0;
unsigned long interval5 = 1000;
//millis6 Tempo Ripartenza Pompa dopo carico
unsigned long previousMillis6 = 0;
unsigned long interval6 = 1000;
//millis7 Lampeggio led impianto
unsigned long previousMillis7 = 0;
unsigned long interval7 = 1000;
//millis8 X TEMPORIZZATORE PRIMO AVVIO CALDAIA FREDDA
unsigned long previousMillis8 = 0;
unsigned long interval8 = 1000;
//millis9 LAMPEGGIO PER TURBO
unsigned long previousMillis9 = 0;
unsigned long interval9 = 200;
//millis10 PULIZIA
unsigned long previousMillis10 = 0;
unsigned long interval10 = 1000;
//millis11 PULIZIA
unsigned long previousMillis11 = 0;
unsigned long interval11 = 1000;
//millis12 PULIZIA
unsigned long previousMillis12 = 0;
unsigned long interval12 = 1000;
//millis13 PULIZIA
unsigned long previousMillis13 = 0;
unsigned long interval13 = 1000;
//millis14 OGNI QUANTO LEGGERE LO STATO DELLE TEMPERATURE
unsigned long previousMillis14 = 0;
unsigned long interval14 = 1000;
//millis15 SCRITTA PER MONITOR SERIALE "FERRO SPENTO"
unsigned long previousMillis15 = 0;
unsigned long interval15 = 10000;
//millis16 PER GESTIONE TASTO ACCENSIONE
unsigned long previousMillis16 = 0;
unsigned long interval16 = 2000;
//millis17 ERRORE RESISTENZA CALDAIA ANDATA
unsigned long previousMillis17 = 0;
unsigned long interval17 = 100;
//millis18 PER GESTIONE TASTO OK
unsigned long previousMillis18 = 0;
unsigned long interval18 = 2000;
//millis19 PER CARICO H20, LA SCRITTA SERVE H20
unsigned long previousMillis19 = 0;
unsigned long interval19 = 1000;


//INGRESSI AUSCITE 1,2 NON USATO PERCHE' POSSONO FARE ALTRE FUNZIONI PARTICOLARI




#define ledmode 2   //arancio
#define ledon 3     //giallo
#define ledclean 4  //nero
#define ledh2o 5    //bianco
#define turbo 6     //marrone
#define swa 7       //rosso
#define swok 8      //verde
#define swv 9       //grigio
#define rf 10       // alla fine
#define rc 11       // alla fine
#define ev 12       // alla fine
#define pumpPin 13  // alla fine

//#define h2o 2
// A1 temp ferro verde con calza
// A0 temp caldaia rosso con calza

;
void setup() {
  Serial.begin(9600);
  pinMode(rc, OUTPUT);
  pinMode(rf, OUTPUT);
  pinMode(ledon, OUTPUT);
  pinMode(ledmode, OUTPUT);
  pinMode(ledclean, OUTPUT);
  pinMode(ledh2o, OUTPUT);
  pinMode(swa, INPUT_PULLUP);
  pinMode(swv, INPUT_PULLUP);
  pinMode(swok, INPUT_PULLUP);
  pinMode(ev, OUTPUT);
  pinMode(pumpPin, OUTPUT);
  pinMode(turbo, INPUT_PULLUP);
  pinMode(h2o, INPUT_PULLUP);
}
void loop() {



  //LETTURA TASTO ACCENSIONE
  buttonstatea = digitalRead(swa);
  if (buttonstatea == 0 && valbuttonold == 0) {
    if (millis() - previousMillis16 > interval16) {
      previousMillis16 = millis();
      memon ^= 1;  // Inverte lo stato (da ON a OFF, da OFF a ON)
    }
  }
  valbuttonold = buttonstatea;
  // per una frazione di secondo l'IF non è verificato, quindi si verifica lo scambio memon.


  //------------------------------------------------------------------------- ACCENSIONE IMPIANTO

  tempc = analogRead(A0);
  delay(200);
  if (memon == 1) {  //attaccando la spina questo va subito a 1, se avvio impianto va a 0.
    if (tempc > C or tempf > Df) {
      if (millis() - previousMillis7 > interval7) {
        previousMillis7 = millis();
        if (ledstate == LOW) {
          ledstate = HIGH;
        } else {
          ledstate = LOW;
        }
        digitalWrite(ledon, ledstate);
      }
    } else
      digitalWrite(ledon, HIGH);


    //-----------------------------------------------------------------------------MEMORIA USO CALDAIA
    //memon1 era 254
    if (memon1 < 5) {
      if (millis() - previousMillis3 > interval3) {
        previousMillis3 = millis();
        memon1++;
      }
      EEPROM.write(0, memon1);
    }
    if (memon1 == 5) {
      memclean = 1;  //il ciclo pulizia deve essere fatto
      digitalWrite(ledclean, HIGH);
      EEPROM.write(1, 1);  //scrivo in memoria che deve essere eseguita pulizia
    }


    //-------------------------------------------------------------------------------------GESTIONE PROGRAMMI
    buttonstatet = digitalRead(turbo);
    if (buttonstatet == HIGH && valbuttontold == LOW) {
      memton ^= 1;  // Inverte lo stato (da ON a OFF, da OFF a ON)
    }
    valbuttontold = buttonstatet;

    if (memton == 0) {
      A = tminTURBO;
      B = tmaxTURBO;
      C = tTURBO;  // x gestione resistenza caldaia
      Df = tfturbo;

      if (millis() - previousMillis9 > interval9) {  //ERA 9
        previousMillis9 = millis();
        if (modeblink == LOW) {
          modeblink = HIGH;
        } else {
          modeblink = LOW;
        }
        digitalWrite(ledmode, modeblink);
      }

    } else {
      A = tminECO;
      B = tmaxECO;
      C = tECO;  // x gestione resistenza caldaia
      Df = tfeco;
      if (error == 0) {
        digitalWrite(ledmode, HIGH);
      }
    }



    //------------------------------------------------------------------------------TEMPORIZZATORE PRIMO AVVIO FREDDO
    if ((stop4clean == 0) && (tempc > 300)) {
      timeravvio = 1;
    }

    if (timeravvio == 1 && contaimpulsi < 15) {
      if (millis() - previousMillis8 > interval8) {
        previousMillis8 = millis();
        contaimpulsi++;
        memtemp = 0;  //altrimenti appena finito di avviarsi, ed è in temperatura, carica h20 anche se non serve
        Serial.print("..............................TempoPompaPrimoAvvio FREDDO: ");
        Serial.println(contaimpulsi, DEC);
      }
    }

    if (contaimpulsi == 15 ) {
      controlpump = 1;  // parametro da utilizzare per abilitare ciclo pompa
      
    }

    //--------------------------------------------------------------------------------TEMPORIZZAZZIONE PRIMO AVVIO CALDO
    if ((contaimpulsi1 < 10 && hotstart == 1 && stop4clean == 0 )) {
      if (millis() - previousMillis5 > interval5) {
        previousMillis5 = millis();
        contaimpulsi1++;
        memtemp = 0;  //altrimenti appena finito di avviarsi, ed è in temperatura, carica h20 anche se non serve
        Serial.print("..............................TempoPompaPrimoAvvio CALDO: ");
        Serial.println(contaimpulsi1, DEC);
      }
    }

    if (contaimpulsi1 == 10 or tempc < B) {  //messo tempc perchè se mentre lavoro spengo e accendo, riparte senza attesa!
      controlpump1 = 1;                            // parametro da utilizzare per abilitare ciclo pompa
      
    }



    // -------------------------------------------------------------------------------ERRORE RISCALDAMENTO CALDAIA
    if ((tempc > 300 or tempf > 300) && (controlpump == 1 or controlpump1 == 1) && stop4clean == 0) {
      error = 1;
      if (millis() - previousMillis17 > interval17) {
        previousMillis17 = millis();
        if (heatingerror == LOW) {
          heatingerror = HIGH;
        } else {
          heatingerror = LOW;
        }
        digitalWrite(ledon, heatingerror);
        digitalWrite(ledmode, heatingerror);
        digitalWrite(ledclean, heatingerror);
        digitalWrite(ledh2o, heatingerror);
        digitalWrite(rf, LOW);
        digitalWrite(rc, LOW);
        digitalWrite(pumpPin, LOW);
      }
    }

    //--------------------------------------------------------------------------------------GESTIONE TASTO OK

    buttonstateok = digitalRead(swok);
    if (buttonstateok == LOW && valbuttonokold == LOW) {
      if (millis() - previousMillis18 > interval18) { //evito che ci sia la doppia lettura
        previousMillis18 = millis();

      memokon ^= 1;  // Inverte lo stato (da ON a OFF, da OFF a ON)
    }}
    valbuttonokold = buttonstateok;


    //-----------------------------------------------------------------------------------------PULIZIA CALDAIA
    if (memokon == 1 && stop4clean == 1 && cleantime < 10 && loadh2o < 3) {  //avvio ciclo
      digitalWrite(ledclean, LOW);
      if (millis() - previousMillis10 > interval10) {
        previousMillis10 = millis();
        cleantime++;
        Serial.println("Carico acqua dopo svuotamento caldaia");
        Serial.println(cleantime, DEC);
      }
      //pumpa pumpb è per riuscire a gestire i tempi di pompa accesa e spenta separatamente
      if (pumpa < 8) {
        if (millis() - previousMillis11 > interval11) {
          previousMillis11 = millis();
          pumpa++;
          pumpon = 1;  //già dichiarato
        }
      }
      if (pumpa == 8 and pumpb < 5) {
        if (millis() - previousMillis12 > interval12) {
          previousMillis12 = millis();
          pumpb++;
          pumpon = 0;
          if (pumpb == 5) {
            pumpa = 0;
            pumpb = 0;
          }
        }
      }
      digitalWrite(pumpPin, pumpon);
    } else{
      
    }

    if (cleantime == 10 and cleandelay < 10) {  //CLEANTIME 80, cleandelay 30
      if (millis() - previousMillis13 > interval13) {
        previousMillis13 = millis();
        cleandelay++;

        digitalWrite(pumpPin, LOW);  //se rimane pompa accesa dal ciclo precedente, la forzo spenta
        Serial.println("Attendo 10 secondi prima di caricare altra acqua se serve");
        Serial.print(cleandelay, DEC);
      }
    }

    if (cleandelay == 10 && stop4clean == 1) {  // messo stop4clean cosi l'if viene eseguito solo 1 volta!
      memon1 = 0;                               //per rifar partire la memoria uso caldaia
      memtemp = 0;
      memclean = 0;  //per rifar partire la memoria uso caldaia
      EEPROM.write(1, 0); //scivo nella memoria memclean il valore 0
      stop4clean = 0;
      previousMillis13 = 0;
      digitalWrite(ledclean, LOW);
      contaimpulsi1 = 10;
      cleantime = 0;
      pumpa = 0;
      pumpb = 0;
      cleandelay = 0;
    }



    //---------------------------------------------------------------------------------------------GESTIONE FERRO
    if (millis() - previousMillis2 > interval2) {
      previousMillis2 = millis();
      tempf = analogRead(A1);
      Serial.print("         NTF: ");
      Serial.print(tempf, DEC);
    }
    if (tempf > Df && error == 0 && errorh2o == 0 && (stop4clean == 0 or memokon == 1)) {
      digitalWrite(rf, HIGH);
    } else {
      digitalWrite(rf, LOW);
    }

    buttonstatev = digitalRead(9);

    if ((tempc < 100) && (buttonstatev == 0)) {  //per limitare utilizzo tasto vapore
      digitalWrite(ev, HIGH);
    } else if (buttonstatev == 1) {
      digitalWrite(ev, LOW);
    }

    // -----------------------------------------------------------------------------------POMPA E CALDAIA

    if (millis() - previousMillis1 > interval1) {
      previousMillis1 = millis();
      tempc = analogRead(A0);
      Serial.print("      NTC: ");
      Serial.println(tempc, DEC);
      //
      Serial.print("Conteggio 0-254 --->");
      Serial.print(EEPROM.read(0));
      Serial.print("       stop4clean -->");
      Serial.print(stop4clean, DEC);
      Serial.print("       memokon");
      Serial.print(memokon, DEC);
      Serial.print("       errorh2o");
      Serial.print(errorh2o, DEC);
      Serial.print("       contaimpulsi");
      Serial.println(contaimpulsi, DEC);


      //se chiudo l'IF qui l'abilitazione pompa non funziona bene!

      if (((tempc < A || tempc > B) && (controlpump == 1 or controlpump1 == 1)) && stop4clean == 0 && surepumptemp == 1 && errorh2o == 0) {
        memtemp = 1;  // Memorizzo la richiesta di acqua e faccio finire il carico stabilito
        if (millis() - previousMillis14 > interval14) {
          previousMillis14 = millis();
          Serial.println("Serve H2O");
        }
      }

    }  // la seconda graffa ha risolto tutti i problemi di abilitazioni errate della pompa!!
       // chiudendo l'IF qui, la comparazione della lettura con i valori di attivazione
       // avviene soltanto con i tempi del millis !!!

    //RESISTENZA CALDAIA
    if (tempc > C && error == 0 && errorh2o == 0 && (stop4clean == 0 || memokon == 1)) {
      digitalWrite(rc, HIGH);
    } else {
      digitalWrite(rc, LOW);
    }

    //SICUREZZA POMPA
    if (tempc < 60 && tempc != 0) {  // abilita la pompa solo sotto i 60
      surepumptemp = 1;
    } else {
      surepumptemp = 0;
      if (stop4clean == 0)
        digitalWrite(pumpPin, LOW);
    }



    //CARICO ACQUA MANUALE
    buttonstateh2o = digitalRead(h2o);
    if (buttonstateh2o == 0) {
      memh2o++;
    }
    //ABILITAZIONE POMPA

    if ((pumpCont < 3) and (memh2o > 0 or memtemp == 1) and surepumptemp == 1) {
      if (millis() - previousMillis4 > interval4) {
        previousMillis4 = millis();
        pumpState ^= 1;
        if (pumpState == 1) {
          digitalWrite(pumpPin, HIGH);
          Serial.print("*********Conteggio*********");
          Serial.println(pumpCont, DEC);
        } else {
          digitalWrite(pumpPin, LOW);
          //Serial.print("Conteggio ");
          //Serial.println(pumpCont, DEC);
          pumpCont++;
        }
      }
if (millis() - previousMillis19 > interval19) {
        previousMillis19 = millis();
        Serial.print("*********CARICO H20 IN CORSO*********");
         
    }}


    // RESET ABILITAZIONE POMPA PER NUOVO RICARICO
    if (pumpCont == 3 && timepump < 5) {  //era 15, ma troppo poco, 20 sembra ok
      if (millis() - previousMillis6 > interval6) {
        previousMillis6 = millis();
        timepump++;
        Serial.print("******************************Ricarico Pompa dopo: ");
        Serial.println(timepump, DEC);
      }
    }
    if (timepump == 5) {
      pumpCont = 0;
      memtemp = 0;
      memh2o = 0;
      loadh2o++;
      timepump = 0;
      memokon = 0;  //resetto lo stato del tasto OK. se premo il tasto a caso.

      if (millis() - previousMillis3 > interval3) {
        previousMillis3 = millis();
        Serial.print("conteggio carichi");
        Serial.println(loadh2o, DEC);
      }
    }

    // MANCANZA H2O
    if (tempc < B && tempc > A) {  //resetto contatore carico h20 se tutto va bene
      loadh2o = 0;
    }
    if (loadh2o == 3) {
      digitalWrite(ledh2o, HIGH);
      errorh2o = 1;
    }
    if (loadh2o == 3 && memokon == 1 && stop4clean == 0) {
      digitalWrite(ledh2o, LOW);
      errorh2o = 0;
      loadh2o = 0;
      memokon = 0;
    }
  } else {

    //-------------------------------------------------ELSE del primo IF sull'accensione impianto
    
    //setto i valori del programma selezionato
     if (memton == 0) {
      A = tminTURBO;
      B = tmaxTURBO;
      C = tTURBO;  // x gestione resistenza caldaia
      Df = tfturbo;
     } else {
       A = tminECO;
      B = tmaxECO;
      C = tECO;  // x gestione resistenza caldaia
      Df = tfeco;
     }
    
    
    
    memon1 = EEPROM.read(0);    // memorizzo lo stato del timer dell'ultimo avvio prima di accendere impianto
    memclean = EEPROM.read(1);  // riprendo nel programma se è necessario pulizia
    
    if (memon1 == 255) {        // al primo avvio a memoria vuota, azzera la variabile
      memon1 = 0;
    }
    if (memon1 == 5) {
      digitalWrite(ledclean, HIGH);
    }
    if (memclean == 1 && (tempc > 300)) {  // se accendo impianto, è tutto fermo per necessaria pulizia
      stop4clean = 1;
    }
    if (millis() - previousMillis1 > interval1) {
      previousMillis1 = millis();
      tempc = analogRead(A0);
      tempf = analogRead(A1);
      Serial.print("      NTC-FERRO: ");
      Serial.print(tempf, DEC);
      Serial.print("      NTC-CALDAIA: ");
      Serial.println(tempc, DEC);
      //
      Serial.print("Conteggio 0-254 -->");
      Serial.print(EEPROM.read(0));
      Serial.print("       memOKon");
      Serial.print(memokon, DEC);
      Serial.print("       controlpump1 --->");
      Serial.print(controlpump1, DEC);
       Serial.print("       stop4clean -->");
      Serial.println(stop4clean, DEC);
    }
    // per far partire il timer di primo avvio

if (tempc < 150 && tempc > B  ){ // se spengo e accendo mentre è caldo, funziona tutto senza attesa
    hotstart = 1;
} else {
hotstart = 0;
}

if (tempc > A && tempc < B){
controlpump1 = 1;
} else {
 controlpump1 = 0;
}
      
    contaimpulsi1 = 0;
    contaimpulsi = 0; 
    controlpump = 0;
    timeravvio = 0;
    memokon = 0;  //permette di far funzionare il tasto ok per una nuova pulizia se non stacco mai spina
 memtemp = 0;
 errorh2o = 0;




    //GESTIONE EV VAPORE, messo fuori dall'if iniziale per fare andare il tasto vapore con sistema spento.

    buttonstatev = digitalRead(9);
    if (buttonstatev == 1) {
      digitalWrite(ev, LOW);
    } else {
      digitalWrite(ev, HIGH);
    }

    digitalWrite(ledon, LOW);
    digitalWrite(rf, LOW);
    digitalWrite(rc, LOW);
    digitalWrite(pumpPin, LOW);
    digitalWrite(ledmode, LOW);
   

    //if (millis() - previousMillis15 > interval15) {
    // previousMillis15 = millis();
    //buttonstatea = digitalRead(swa);
    //Serial.println("FERRO SPENTO");
  }
}