const int ledpinEV1 = 22; // setta il pin elettrovalvola e led
const int ledpinEV2 = 23; //setta il pin elettrovalvola e led
const int ledpinEV3 = 24; //setta il pin elettrovalvola e led
const int ledpinEV4 = 25; //setta il pin elettrovalvola e led
const int ledpinPom = 26; //setta il pin elettrovalvola e led
const int ledpinRes = 27; //setta il pin elettrovalvola e led



//**************************** --CONTROLLO FLUSSO 1--2 *******************************************
//BLOCCO DICHIARAZIONI VARIABILI CONTROLLO FLUSSO
const float Pi = 3.141593; // Pigreco
const float raggio = 0.06; // raggio flussometro in metri

const int reed1Pin = 18;     // pin assegnato al contatto reed SIGLATO D1 ADESIVO COLORE FILO MARRONE
const int reed2Pin = 19;     // pin assegnato al contatto reed SIGLATO D2 ADESIVO COLORE FILO MARRONE
const int reed3Pin = 20;     // pin assegnato al contatto reed SIGLATO D3 ADESIVO COLORE FILO MARRONE
const int reed4Pin = 21;     // pin assegnato al contatto reed SIGLATO D4 ADESIVO COLORE FILO MARRONE

int Statoreed1 = 0;         // variabile per la lettura del contatto
int Statoreed2 = 0;         // variabile per la lettura del contatto
int Statoreed3 = 0;         // variabile per la lettura del contatto
int Statoreed4 = 0;         // variabile per la lettura del contatto

int Statoreed1_old = 0;     // variabile per evitare doppio conteggio
int Statoreed2_old = 0;     // variabile per evitare doppio conteggio
int Statoreed3_old = 0;     // variabile per evitare doppio conteggio
int Statoreed4_old = 0;     // variabile per evitare doppio conteggio

int Conteggio1 = 0;         // variabile che contiene il conteggio delle pulsazioni
int Conteggio2 = 0;         // variabile che contiene il conteggio delle pulsazioni
int Conteggio3 = 0;         // variabile che contiene il conteggio delle pulsazioni
int Conteggio4 = 0;         // variabile che contiene il conteggio delle pulsazioni

float valueflu1 = 0;
float valueflu2 = 0;
float valueflu3 = 0;
float valueflu4 = 0;

unsigned long int TempoStart1 = 0;  // memorizza i  millisecondi dalla prima pulsazione conteggiata
unsigned long int TempoStart2 = 0;  // memorizza i  millisecondi dalla prima pulsazione conteggiata
unsigned long int TempoStart3 = 0;  // memorizza i  millisecondi dalla prima pulsazione conteggiata
unsigned long int TempoStart4 = 0;  // memorizza i  millisecondi dalla prima pulsazione conteggiata

unsigned long int Tempo1 = 0;       // per conteggiare il tempo trascorso dalla prima pulsazione
unsigned long int Tempo2 = 0;       // per conteggiare il tempo trascorso dalla prima pulsazione
unsigned long int Tempo3 = 0;       // per conteggiare il tempo trascorso dalla prima pulsazione
unsigned long int Tempo4 = 0;       // per conteggiare il tempo trascorso dalla prima pulsazione

unsigned long int TempoMax1 = 1000; // numero di millisecondi (2 seondi) // modificato a 1 secondi
unsigned long int TempoMax2 = 1000; // numero di millisecondi (2 seondi) // modificato a 1 secondi
unsigned long int TempoMax3 = 1000; // numero di millisecondi (2 seondi) // modificato a 1 secondi
unsigned long int TempoMax4 = 1000; // numero di millisecondi (2 seondi) // modificato a 1 secondi
//per azzerare il conteggio e calcolare la Velocità
// così non si conteggiano brevi movimenti di flusso

//********************************************************************************************




void setup() {
  Serial.begin(9600);               // ABILITA LA SERIALE
  pinMode(reed1Pin, INPUT);          // mette in ascolto il reed sul pin 2  pinMode(INPUT);
  pinMode(reed2Pin, INPUT);
  pinMode(reed3Pin, INPUT);
  pinMode(reed4Pin, INPUT);
  pinMode(ledpinEV1, OUTPUT);
  pinMode(ledpinEV2, OUTPUT);
  pinMode(ledpinEV3, OUTPUT);
  pinMode(ledpinEV4, OUTPUT);
  pinMode(ledpinPom, OUTPUT);
  pinMode(ledpinRes, OUTPUT);
  attachInterrupt (5, reed1Pins, RISING);  //Configura interrupt 5 al pin 18
  attachInterrupt (4, reed2Pins, RISING);  //Configura interrupt 4 al pin 19
  attachInterrupt (3, reed3Pins, RISING);  //Configura interrupt 3 al pin 20
  attachInterrupt (2, reed4Pins, RISING);  //Configura interrupt 2 al pin 21
}


void loop() {

  // FLUSSOMETRO 1 -**********************************************************
  Statoreed1 = digitalRead(reed1Pin); // legge il contatto reed

  if (Statoreed1 != Statoreed1_old) {
    //  verifica se è cambiato
    Statoreed1_old = Statoreed1;   // se "SI" aggiorna lo stato
    if (Statoreed1 == HIGH) { // controlla SE è alto ( passaggio magnete)
      if (Conteggio1 == 0) {
        TempoStart1 =  millis(); // se E' il primo passaggio si memorizza il tempo di partenza
      }
      Conteggio1 = Conteggio1 + 1; // si aggiorna il contatore
      Tempo1 = ( millis() - TempoStart1); //  conteggia il tempo trascorso dallo start conteggio
      if (Tempo1 >=  TempoMax1) {  // se il tempo trascorso è maggiore o uguale al tempo impostato si eseguono i
        //calcoli e la stampa della velocità
        float deltaTempo = ( Tempo1 / 1000.0); // si trasforma in secondi
        valueflu1 = (3.6 * Conteggio1 * Pi * raggio) / deltaTempo; //formula per il calcolo della velocità in Km/h
        //Serial.print("Flus 1 :" ); Serial.println(valueflu);

        Conteggio1 = 0; // azzeriamo il conteggio per nuova lettura
        delay(500);// attesa per altra lettura
        Serial.print(""); Serial.println(valueflu1);
      }
    }
  }


  // FLUSSOMETRO 2-************************************************
  Statoreed2 = digitalRead(reed2Pin); // legge il contatto reed

  if (Statoreed2 != Statoreed2_old) { //  verifica se è cambiato
    Statoreed2_old = Statoreed2;   // se "SI" aggiorna lo stato

    if (Statoreed2 == HIGH) { // controlla SE è alto ( passaggio magnete)
      if (Conteggio2 == 0) {
        TempoStart2 =  millis(); // se E' il primo passaggio si memorizza il tempo di partenza
      }
      Conteggio2 = Conteggio2 + 1; // si aggiorna il contatore
      Tempo2 = ( millis() - TempoStart2); //  conteggia il tempo trascorso dallo start conteggio
      if (Tempo2 >=  TempoMax2) {  // se il tempo trascorso è maggiore o uguale al tempo impostato si eseguono i
        //calcoli e la stampa della velocità
        float deltaTempo2 = ( Tempo2 / 1000.0); // si trasforma in secondi
        valueflu2 = (3.6 * Conteggio2 * Pi * raggio) / deltaTempo2; //formula per il calcolo della velocità in Km/h
        Conteggio2 = 0; // azzeriamo il conteggio per nuova lettura
        delay(500);// attesa per altra lettura

        Serial.print("\t"); Serial.println(valueflu2);
      }
    }
  }



  // FLUSSOMETRO 3-************************************************
  Statoreed3 = digitalRead(reed3Pin); // legge il contatto reed
  if (Statoreed3 != Statoreed3_old) { //  verifica se è cambiato
    Statoreed3_old = Statoreed3;   // se "SI" aggiorna lo stato

    if (Statoreed3 == HIGH) { // controlla SE è alto ( passaggio magnete)
      if (Conteggio3 == 0) {
        TempoStart3 =  millis(); // se E' il primo passaggio si memorizza il tempo di partenza
      }
      Conteggio3 = Conteggio3 + 1; // si aggiorna il contatore
      Tempo3 = ( millis() - TempoStart3); //  conteggia il tempo trascorso dallo start conteggio
      if (Tempo3 >=  TempoMax3) {  // se il tempo trascorso è maggiore o uguale al tempo impostato si eseguono i
        //calcoli e la stampa della velocità
        float deltaTempo3 = ( Tempo3 / 1000.0); // si trasforma in secondi
        valueflu3 = (3.6 * Conteggio3 * Pi * raggio) / deltaTempo3; //formula per il calcolo della velocità in Km/h
        Conteggio3 = 0; // azzeriamo il conteggio per nuova lettura
        delay(500);// attesa per altra lettura

        Serial.print("\t\t"); Serial.println(valueflu3);
      }
    }
  }


  // FLUSSOMETRO 4-************************************************
  Statoreed4 = digitalRead(reed4Pin); // legge il contatto reed
  if (Statoreed4 != Statoreed4_old) { //  verifica se è cambiato
    Statoreed4_old = Statoreed4;   // se "SI" aggiorna lo stato

    if (Statoreed4 == HIGH) { // controlla SE è alto ( passaggio magnete)
      if (Conteggio4 == 0) {
        TempoStart4 =  millis(); // se E' il primo passaggio si memorizza il tempo di partenza
      }
      Conteggio4 = Conteggio4 + 1; // si aggiorna il contatore
      Tempo4 = ( millis() - TempoStart4); //  conteggia il tempo trascorso dallo start conteggio
      if (Tempo4 >=  TempoMax4) {  // se il tempo trascorso è maggiore o uguale al tempo impostato si eseguono i
        //calcoli e la stampa della velocità
        float deltaTempo4 = ( Tempo4 / 1000.0); // si trasforma in secondi
        valueflu4 = (3.6 * Conteggio4 * Pi * raggio) / deltaTempo4; //formula per il calcolo della velocità in Km/h
        Conteggio4 = 0; // azzeriamo il conteggio per nuova lettura
        delay(500);// attesa per altra lettura
        //Serial.print("\tFlus 1 : ");Serial.print(valueflu);Serial.print(" ");
        Serial.print("\t\t\t"); Serial.println(valueflu4);
      }
    }
  }



  if (Serial.available()) {
    char fromSerial = ' ';
    fromSerial = Serial.read();
    switch (fromSerial) {
      case 'a':
        digitalWrite(ledpinEV1, HIGH);
        break;
      case 'h':
        digitalWrite(ledpinEV1, LOW);
        break;
      case 'b':
        digitalWrite(ledpinEV2, HIGH);
        break;
      case 'i':
        digitalWrite(ledpinEV2, LOW);
        break;
      case 'd':
        digitalWrite(ledpinEV3, HIGH);
        break;
      case 'l':
        digitalWrite(ledpinEV3, LOW);
        break;
      case 'e':
        digitalWrite(ledpinEV4, HIGH);
        break;
      case 'm':
        digitalWrite(ledpinEV4, LOW);
        break;
      case 'f':
        digitalWrite(ledpinRes, HIGH);
        break;
      case 'n':
        digitalWrite(ledpinRes, LOW);
        break;
      case 'g':
        digitalWrite(ledpinPom, HIGH);
        break;
      case 'o':
        digitalWrite(ledpinPom, LOW);
        break;
      case 'p':
        Serial.println("Vado in Test()");
        Test();
        Serial.println("Uscito da Test()");
        break;
      case 'q':
        digitalWrite(ledpinEV4, LOW);
        break;
      default:
        break;
    }
  }

}


void reed1Pins() {

  // FLUSSOMETRO 1 -**********************************************************
  Statoreed1 = digitalRead(reed1Pin); // legge il contatto reed

  if (Statoreed1 != Statoreed1_old) { //  verifica se è cambiato
    Statoreed1_old = Statoreed1;   // se "SI" aggiorna lo stato
    if (Statoreed1 == HIGH) { // controlla SE è alto ( passaggio magnete)
      if (Conteggio1 == 0) {
        TempoStart1 =  millis(); // se E' il primo passaggio si memorizza il tempo di partenza
      }
      Conteggio1 = Conteggio1 + 1; // si aggiorna il contatore
      Tempo1 = ( millis() - TempoStart1); //  conteggia il tempo trascorso dallo start conteggio
      if (Tempo1 >=  TempoMax1) {  // se il tempo trascorso è maggiore o uguale al tempo impostato si eseguono i
        //calcoli e la stampa della velocità
        float deltaTempo = ( Tempo1 / 1000.0); // si trasforma in secondi
        valueflu1 = (3.6 * Conteggio1 * Pi * raggio) / deltaTempo; //formula per il calcolo della velocità in Km/h
        //Serial.print("Flus 1 :" ); Serial.println(valueflu);

        Conteggio1 = 0; // azzeriamo il conteggio per nuova lettura
        delay(500);// attesa per altra lettura
        Serial.print("1 "); Serial.println(valueflu1);
      }
    }
  }
}
void reed2Pins() {
  // FLUSSOMETRO 2-************************************************
  Statoreed2 = digitalRead(reed2Pin); // legge il contatto reed

  if (Statoreed2 != Statoreed2_old) { //  verifica se è cambiato
    Statoreed2_old = Statoreed2;   // se "SI" aggiorna lo stato

    if (Statoreed2 == HIGH) { // controlla SE è alto ( passaggio magnete)
      if (Conteggio2 == 0) {
        TempoStart2 =  millis(); // se E' il primo passaggio si memorizza il tempo di partenza
      }
      Conteggio2 = Conteggio2 + 1; // si aggiorna il contatore
      Tempo2 = ( millis() - TempoStart2); //  conteggia il tempo trascorso dallo start conteggio
      if (Tempo2 >=  TempoMax2) {  // se il tempo trascorso è maggiore o uguale al tempo impostato si eseguono i
        //calcoli e la stampa della velocità
        float deltaTempo2 = ( Tempo2 / 1000.0); // si trasforma in secondi
        valueflu2 = (3.6 * Conteggio2 * Pi * raggio) / deltaTempo2; //formula per il calcolo della velocità in Km/h
        Conteggio2 = 0; // azzeriamo il conteggio per nuova lettura
        delay(500);// attesa per altra lettura
        //Serial.print("\tFlus 1 : ");Serial.print(valueflu);Serial.print(" ");
        Serial.print("\t2 "); Serial.println(valueflu2);
      }
    }
  }
}

void reed3Pins() {
  // FLUSSOMETRO 3-************************************************
  Statoreed3 = digitalRead(reed3Pin); // legge il contatto reed
  if (Statoreed3 != Statoreed3_old) { //  verifica se è cambiato
    Statoreed3_old = Statoreed3;   // se "SI" aggiorna lo stato

    if (Statoreed3 == HIGH) { // controlla SE è alto ( passaggio magnete)
      if (Conteggio3 == 0) {
        TempoStart3 =  millis(); // se E' il primo passaggio si memorizza il tempo di partenza
      }
      Conteggio3 = Conteggio3 + 1; // si aggiorna il contatore
      Tempo3 = ( millis() - TempoStart3); //  conteggia il tempo trascorso dallo start conteggio
      if (Tempo3 >=  TempoMax3) {  // se il tempo trascorso è maggiore o uguale al tempo impostato si eseguono i
        //calcoli e la stampa della velocità
        float deltaTempo3 = ( Tempo3 / 1000.0); // si trasforma in secondi
        valueflu3 = (3.6 * Conteggio3 * Pi * raggio) / deltaTempo3; //formula per il calcolo della velocità in Km/h
        Conteggio3 = 0; // azzeriamo il conteggio per nuova lettura
        delay(500);// attesa per altra lettura
        //Serial.print("\tFlus 1 : ");Serial.print(valueflu);Serial.print(" ");
        Serial.print("\t\t3 "); Serial.println(valueflu3);
      }
    }
  }
}
void reed4Pins() {
  // FLUSSOMETRO 4-************************************************
  Statoreed4 = digitalRead(reed4Pin); // legge il contatto reed
  if (Statoreed4 != Statoreed4_old) { //  verifica se è cambiato
    Statoreed4_old = Statoreed4;   // se "SI" aggiorna lo stato

    if (Statoreed4 == HIGH) { // controlla SE è alto ( passaggio magnete)
      if (Conteggio4 == 0) {
        TempoStart4 =  millis(); // se E' il primo passaggio si memorizza il tempo di partenza
      }
      Conteggio4 = Conteggio4 + 1; // si aggiorna il contatore
      Tempo4 = ( millis() - TempoStart4); //  conteggia il tempo trascorso dallo start conteggio
      if (Tempo4 >=  TempoMax4) {  // se il tempo trascorso è maggiore o uguale al tempo impostato si eseguono i
        //calcoli e la stampa della velocità
        float deltaTempo4 = ( Tempo4 / 1000.0); // si trasforma in secondi
        valueflu4 = (3.6 * Conteggio4 * Pi * raggio) / deltaTempo4; //formula per il calcolo della velocità in Km/h
        Conteggio4 = 0; // azzeriamo il conteggio per nuova lettura
        delay(500);// attesa per altra lettura
        //Serial.print("\tFlus 1 : ");Serial.print(valueflu);Serial.print(" ");
        Serial.print("\t\t\t4 "); Serial.println(valueflu4);
      }
    }
  }

}
void Test() {

  uint32_t measureTime;
  //valueflu1 = 0.00;


  if (millis() - measureTime > 1000) {
    measureTime = millis();

    if (valueflu1 < 30) {
      digitalWrite(ledpinEV1, HIGH);
      Serial.println("EV1ON"); Serial.print(" ");
      Serial.println(valueflu1);
      millis();
      digitalWrite(ledpinPom, HIGH);
      Serial.println("PomON"); Serial.print(" ");
      Serial.println(valueflu1);
      millis();
    } else if (valueflu1 > 30) {
      Serial.println("sei in while");
      digitalWrite(ledpinEV1 , LOW);
      Serial.println("EV1OFF");
      millis();
      Serial.print(" ");
      digitalWrite(ledpinPom, LOW);
      Serial.println("PomOFF");
      Serial.print(" ");
    } else {
      Test();
    }
    return true;
  }


}