//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 ledstateon = 0;   //blowing
int ledstateoff = 0;  //blowing
//Ciclo primo avvio Pompa
unsigned long contatore;
unsigned long contaimpulsi;  // timer avvio a freddo
int controlpump = 0;         //usato per caldaia fredda
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 memon2 = 0;
int memton = 0;
int memokon = 0;
int valbuttonold = 0;
int valbuttontold = 0;
int valbuttonokold = 0;
int loadh2o = 0;
int steamon = 0;
int preheat = 0;
int timepreheat = 0;
int evtimestartup = 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;
int ledstateclean = 0;
int forceclean = 0;
int manualcleanon = 0;

// TIMER AUTOSPEGNIMENTO
int usetime = 0;
int delayled = 0;

// ERRORE H20
int timelowh2o = 0;
int rcon = 0;

// VARIE
int systemon = 0;





//PROGRAMMI
int A;
int B;
int C;
int Df;


//ECO
int tminECO = 26;   // a caldaia quasi vuota scende a 17. 24 è scarso. provo 26.
int tmaxECO = 225;  // 325 troppo alto non arriva a caricare, 270 no, 250 è alto.
int tECO = 100;     // 100
int tfeco = 150;    // 120 OK, ma abbassato a 150 perchè sulla plastica scorreva poco.

//TURBO
int tminTURBO = 20;   // 18 sembra non male. ma aperto tappo e misurato acqua, è poca. provo 20
int tmaxTURBO = 120;  // 150 troppo alto, con zia poco vapore.
int tTURBO = 25;      // 20 vapore molto forte, è A FILO L'INTERVENTO DELLA SICUREZZA, SI SENTE LEGGERO SFIATO.
int tfturbo = 60;     // 25 BRUCIA pyle !!


//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 = 71000;
//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 BLOW LED
unsigned long previousMillis4 = 0;
unsigned long interval4 = 50;
//millis5 TIMER AUTOSPEGNIMENTO
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 PER GESTIONE TASTO OK A SISTEMA SPENTO PER FORZARE PULIZIA
unsigned long previousMillis15 = 0;
unsigned long interval15 = 1000;
//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 = 300;
//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;
//millis20 PULIZIA - LAMPEGGIO LED
unsigned long previousMillis20 = 0;
unsigned long interval20 = 200;
//millis21 GESTIONE TASTO VAPORE PER ANTICIPO RESISTENZA
unsigned long previousMillis21 = 0;
unsigned long interval21 = 1000;
//millis22 GESTIONE TASTO VAPORE PER ANTICIPO RESISTENZA
unsigned long previousMillis22 = 0;
unsigned long interval22 = 1000;
//millis23 BLOW LED
unsigned long previousMillis23 = 0;
unsigned long interval23 = 50;
//millis24 ERRORE H20
unsigned long previousMillis24 = 0;
unsigned long interval24 = 1000;
//millis24 BLOW LED
unsigned long previousMillis25 = 0;
unsigned long interval25 = 100;

//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 caldaia verde con calza
// A0 temp ferro 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);
  buttonstatev = digitalRead(9);

  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.








  if (memon == 1 && usetime < 180) {  //------------------------------------------------------------------------- ACCENSIONE IMPIANTO

    if (controlpump == 1) {
      if (millis() - previousMillis5 > interval5) {
        previousMillis5 = millis();
        usetime++;
      }
    }


    forceclean = 0;  // all'avvio della pulizia resetto il contatore usato a sistema spento per forzare pulizia, attaccando la spina questo va subito a 1, se avvio impianto va a 0.
    if ((tempc > C or tempf > Df) && stop4clean == 0 && errorh2o == 0 && error == 0) {
      if (millis() - previousMillis7 > interval7) {
        previousMillis7 = millis();
        if (ledstate == LOW) {
          ledstate = HIGH;
        } else {
          ledstate = LOW;
        }
        digitalWrite(ledon, ledstate);
      }
    } else {
      if (errorh2o == 0 && error == 0) {
        digitalWrite(ledon, HIGH);
      }
    }

    buttonstatev = digitalRead(9);  //per avere tasto ev reattivo, lo faccio leggere in 2 punti
    if (buttonstatev == 1 && tempc < 850) {
      digitalWrite(ev, LOW);
    } else {
      digitalWrite(ev, HIGH);
    }
    //-----------------------------------------------------------------------------MEMORIA USO CALDAIA

    if (memon1 < 254 && error == 0) {  //memon1 era 254
      if (millis() - previousMillis3 > interval3) {
        previousMillis3 = millis();
        memon1++;
      }
      EEPROM.write(0, memon1);
    }
    if (memon1 == 254) {   //254
      memclean = 1;        //il ciclo pulizia deve essere fatto
      EEPROM.write(1, 1);  //scrivo in memoria che deve essere eseguita pulizia
      if (memokon == 0) {  // perchè faccio lampeggiare nel ciclo pulizia, quando pulizia è in corso
        digitalWrite(ledclean, HIGH);
      }
    }
    //-------------------------------------------------------------------------------------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) {
        previousMillis9 = millis();
        if (modeblink == LOW) {
          modeblink = HIGH;
        } else {
          modeblink = LOW;
        }
        if (error == 0 && errorh2o == 0) {
          digitalWrite(ledmode, modeblink);
        }
      }

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

    //------------------------------------------------------------------------------TEMPORIZZATORE PRIMO AVVIO FREDDO

    if (stop4clean == 0 && manualcleanon == 0 && tempc > B && contaimpulsi < 200) {
      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 == 200 || tempc < B) {
      controlpump = 1;  // parametro da utilizzare per abilitare ciclo pompa
      contaimpulsi = 200;
    }

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

        digitalWrite(rf, LOW);
        digitalWrite(rc, LOW);
        digitalWrite(pumpPin, LOW);
      }
    }

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

    buttonstateok = digitalRead(swok);
    if (errorh2o == 1 || stop4clean == 1) {
      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;
    }

    if (buttonstatet == LOW) {  //durante il cambio programma, azzero la richiesta vapore
      memtemp = 0;
    }

    //-----------------------------------------------------------------------------------------PULIZIA CALDAIA
    //PARAMETRI: pumpa 10, b5, cleantime 135 troppa acqua. 105 troppa. 5 min prima di essere pronto. da usare 90, ma frazionare avvio pompa
    // La pompa deve caricare il tutto 60sec per avere acqua giusta, meglio un po di piu.
    // cleantime 180, pumpa 5, pumpb 10,  tempo off troppo lungo.
    // cleantime 156, pumpa 5, pumpb 8 ? non ho provato perchè deciso di caricare + acqua
    // cleantime 156, pumpa 5, pumpb 7, totale carico h20 65s. credo perfetto. controlla che non serva poi acqua quando va a regime minimo
    if ((memokon == 1 && stop4clean == 1 && cleantime < 156) || (manualcleanon == 1 && cleantime < 156)) {
      forceclean = 0;
      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 < 5) {
        if (millis() - previousMillis11 > interval11) {
          previousMillis11 = millis();
          pumpa++;
          pumpon = 1;
        }
      }
      if (pumpa == 5 && pumpb < 7) {  //14, 5 non va bene. metti 3
        if (millis() - previousMillis12 > interval12) {
          previousMillis12 = millis();
          pumpb++;
          pumpon = 0;
          if (pumpb == 7) {
            pumpa = 0;
            pumpb = 0;
          }
        }
      }
      digitalWrite(pumpPin, pumpon);
    }

    if (cleantime == 156 && cleandelay < 60) {  //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 prima di caricare altra acqua se serve");
        Serial.print(cleandelay, DEC);
      }
      if (stop4clean == 1) {
        memon1 = 0;  //per rifar partire la memoria uso caldaia
        memclean = 0;
        EEPROM.write(1, 0);  //scivo nella memoria memclean il valore 0
        EEPROM.write(0, 0);
        memokon = 0;
        stop4clean = 0;
      }

      digitalWrite(ledclean, LOW);
    }

    if ((cleandelay == 60 && stop4clean == 1) || (cleandelay == 60 && manualcleanon == 1)) {  // messo stop4clean cosi l'if viene eseguito solo 1 volta!
                                                                                              //per rifar partire la memoria uso caldaia
      memtemp = 0;
      previousMillis10 = 0;
      previousMillis11 = 0;
      previousMillis12 = 0;
      previousMillis13 = 0;
      cleantime = 0;
      pumpa = 0;
      pumpb = 0;
      cleandelay = 0;
      manualcleanon = 0;
    }

    // LAMPEGGIO LED

    if (memokon == 1 && stop4clean == 1) {
      if (millis() - previousMillis20 > interval20) {
        previousMillis20 = millis();
        if (ledstateclean == LOW) {
          ledstateclean = HIGH;
        } else {
          ledstateclean = LOW;
        }
        digitalWrite(ledclean, ledstateclean);
      }
    }

    //---------------------------------------------------------------------------------------------GESTIONE FERRO
    if (millis() - previousMillis2 > interval2) {
      previousMillis2 = millis();
      tempf = analogRead(A0);
      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 (buttonstatev == 0) {

      if (millis() - previousMillis21 > interval21) {
        previousMillis21 = millis();
        steamon++;
      }
      digitalWrite(ev, HIGH);
    } else {
      if (tempc < 850) {
        digitalWrite(ev, LOW);
      }
    }
    //GESTIONE EV AL PRIMO AVVIO FREDDO
    if (tempc > 890) {  //870 da colpo di vapore ?!
      digitalWrite(ev, HIGH);
    }


    // GESTIONE TASTO VAPORE PER ANTICIPO RESISTENZA


    if (steamon > 8 && timepreheat < 6) {
      preheat = 1;
      if (millis() - previousMillis22 > interval22) {
        previousMillis22 = millis();
        timepreheat++;
        Serial.print("diocane");
      }
    }

    if (timepreheat == 6) {
      steamon = 0;
      preheat = 0;
      timepreheat = 0;
    }

    if (tempc > C) {
      timepreheat = 0;
      steamon = 0;
    }



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

    if (millis() - previousMillis1 > interval1) {
      previousMillis1 = millis();
      tempc = analogRead(A1);
      Serial.print("      NTC: ");
      Serial.println(tempc, DEC);
      //Serial.print("steamon --->");
      //Serial.print(steamon, DEC);
      //Serial.print("Conteggio 0-254 --->");
      //Serial.print(EEPROM.read(0));
      //Serial.print("--");
      //Serial.print(memon1, DEC);
      //Serial.print("       stop4clean -->");
      //Serial.print(stop4clean, DEC);
      Serial.print("       memokon -->");
      Serial.print(memokon, DEC);
      Serial.print("       Time4lowH2O -->");
      Serial.print(timelowh2o, DEC);
      Serial.print("       loadh2o -->");
      Serial.print(loadh2o, DEC);
      Serial.print("       errorh2o -->");
      Serial.print(errorh2o, DEC);
      //Serial.print("       pumpCont -->");
      //Serial.print(pumpCont, DEC);
      Serial.print("       preRiscaldo -->");
      Serial.print(timepreheat, DEC);
      Serial.print("       tasto vapore -->");
      Serial.print(steamon, DEC);
      //Serial.print("       errorh2o -->");
      //Serial.print(errorh2o, DEC);
      //Serial.print("       manualcleanon -->");
      //Serial.print(manualcleanon, DEC);
      //Serial.print("       forceclean -->");
      //Serial.println(forceclean, DEC);


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


      if ((tempc < A || tempc > B) && controlpump == 1 && stop4clean == 0 && errorh2o == 0 && error == 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 > 24 && tempc > C && error == 0 && errorh2o == 0 && (stop4clean == 0 || memokon == 1)) || preheat == 1) {
        digitalWrite(rc, HIGH);
        rcon = 1;
        timelowh2o = 0;

      } else {
        digitalWrite(rc, LOW);
        rcon = 0;
      }
    }
    //SICUREZZA POMPA E RESISTENZE
    if (tempc > 35) {    // abilita la pompa solo se sopra la temperatura di sicurezza
      surepumptemp = 1;  // i 4 parametri di seguito per resettare la lettura tasto vapore
                         //
      preheat = 0;       //
                         //
    }

    if (tempc < 25) {
      digitalWrite(rc, LOW);
    }
    if (tempf < 50) {
      digitalWrite(rf, LOW);
    }

    //CARICO ACQUA MANUALE
    buttonstateh2o = digitalRead(h2o);
    if (buttonstateh2o == 0) {
      memh2o++;
    }
    //ABILITAZIONE POMPA
    // pumpcont 33, pumpa 8, pumpb 3 carica troppo. pumpcont 24, pumpa 5, pumpb 3 ?
    if (pumpCont < 24 and (memh2o > 0 or memtemp == 1) and controlpump == 1 and surepumptemp == 1 and errorh2o == 0 and error == 0) {
      if (millis() - previousMillis10 > interval10) {
        previousMillis10 = millis();
        pumpCont++;
      }
      //pumpa pumpb è per riuscire a gestire i tempi di pompa accesa e spenta separatamente
      if (pumpa < 6) {
        if (millis() - previousMillis11 > interval11) {
          previousMillis11 = millis();
          pumpa++;
          pumpon = 1;
        }
      }
      if (pumpa == 6 && pumpb < 4) {  //14, 5 non va bene. metti 3
        if (millis() - previousMillis12 > interval12) {
          previousMillis12 = millis();
          pumpb++;
          pumpon = 0;
          if (pumpb == 4) {
            pumpa = 0;
            pumpb = 0;
          }
        }
      }

      digitalWrite(pumpPin, pumpon);

      if (millis() - previousMillis19 > interval19) {
        previousMillis19 = millis();
        Serial.print("*********CARICO H20 IN CORSO*********");
      }
    }



    // RESET ABILITAZIONE POMPA PER NUOVO RICARICO
    if (pumpCont == 24 && timepump < 45) {  //era 15, ma troppo poco, 20 no, 30 sembrava ok ma meglio 45 ? (ha ricaricato acqua e non serviva)
      if (millis() - previousMillis6 > interval6) {
        previousMillis6 = millis();
        timepump++;
        Serial.print("******************************Ricarico Pompa dopo: ");
        Serial.println(timepump, DEC);
      }

      digitalWrite(pumpPin, LOW);
    }
    if (timepump == 45) {
      memtemp = 0;
      memh2o = 0;
      loadh2o++;
      previousMillis6 = 0;
      previousMillis10 = 0;
      previousMillis11 = 0;
      previousMillis12 = 0;
      Serial.print("conteggio carichi -->");
      Serial.println(loadh2o, DEC);
      pumpCont = 0;
      timepump = 0;
    }




    // MANCANZA H2O
    if (rcon == 0) {
      if (millis() - previousMillis24 > interval24) {
        previousMillis24 = millis();
        timelowh2o++;  //resettata quando rc è ON
      }
      if (tempc > A && tempc < B && timelowh2o == 30) {  //resetto contatore carico h20 se tutto va bene
        loadh2o = 0;
      }
      if (loadh2o == 2 && tempc < A) {
        digitalWrite(ledh2o, HIGH);
        errorh2o = 1;
        digitalWrite(ledon, LOW);
      }
      if (loadh2o == 2 && memokon == 1 && stop4clean == 0) {
        digitalWrite(ledh2o, LOW);
        errorh2o = 0;
        loadh2o = 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;
    }

    if (millis() - previousMillis1 > interval1) {
      previousMillis1 = millis();
      tempc = analogRead(A1);
      tempf = analogRead(A0);
      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("       stop4clean -->");
      Serial.print(stop4clean, DEC);

      //Serial.print("       manualclean -->");
      //Serial.print(manualcleanon, DEC);
      //Serial.print("       forceclean -->");
      //Serial.print(forceclean, DEC);
      Serial.println("     FERRO SPENTO");
    }

    //blowing for idle
    if (usetime == 180 && memon == 1) {  //mettere 180, 3 min

      if (tempc > 250) {
        digitalWrite(rc, HIGH);
      } else {
        digitalWrite(rc, LOW);
      }

      if (tempf > 350) {
        digitalWrite(rf, HIGH);
      } else {
        digitalWrite(rf, LOW);
      }

      if (buttonstatev == 0) {
        usetime = 0;
        ledstateon = 0;
        ledstateoff = 0;
        delayled = 0;
      }

      if (ledstateon < 20) {
        if (millis() - previousMillis4 > interval4) {
          previousMillis4 = millis();

          ledstateon = (ledstateon + 1);
          ledstate = (ledstate + 1);
        }
      }

      if (ledstateon == 20 && ledstateoff < 20) {
        if (millis() - previousMillis23 > interval23) {
          previousMillis23 = millis();

          ledstateoff = (ledstateoff + 1);
          ledstate = (ledstate - 1);
        }
      }

      if (ledstateoff == 20 && delayled < 2) {
        if (millis() - previousMillis25 > interval25) {
          previousMillis25 = millis();
          delayled++;
        }
      }

      if (delayled == 2) {
        ledstateon = 0;
        ledstateoff = 0;
        delayled = 0;
      }
      analogWrite(ledon, ledstate);
    } else {
      digitalWrite(ledon, 0);
      digitalWrite(rf, LOW);
      digitalWrite(rc, LOW);
      ledstateon = 0;
      ledstateoff = 0;
      delayled = 0;
      usetime = 0;
    }





    // GESTIONE MEMORIA USO

    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;
      EEPROM.write(0, 0);
    }
    if (memon1 == 254 || manualcleanon == 1) {
      digitalWrite(ledclean, HIGH);
    } else {
      digitalWrite(ledclean, LOW);
    }

    //if (memon1 < 254 || manualcleanon == 0) {
    //digitalWrite(ledclean, LOW);
    //}

    if (memclean == 1 && (tempc > 900)) {  // se accendo impianto, è tutto fermo per necessaria pulizia
      stop4clean = 1;
    }

    //RESET VARIABILI
    contaimpulsi = 0;
    controlpump = 0;
    memtemp = 0;
    errorh2o = 0;
    error = 0;
    digitalWrite(pumpPin, LOW);
    digitalWrite(ledmode, LOW);
    digitalWrite(ledh2o, LOW);
    //le resistenze le metto a zero nel ciclo piu in alto


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

    // -------------------------------------------------------------------------------ERRORE termocoppie
    if (tempc == 0 or tempf == 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 per carico forzato
    buttonstateok = digitalRead(swok);
    if (buttonstateok == LOW) {
      if (millis() - previousMillis15 > interval15) {
        previousMillis15 = millis();
        forceclean++;
      }
    }
    if (forceclean > 5) {
      manualcleanon = 1;
    } else {
      manualcleanon = 0;
    }
  }
}