/* FUNZIONAMENTO DI DUE SEMAFORI (UNO CHE CONTROLLA LO SCAMBIO E L'ALTRO IL TRATTO DRITTO) ED UNO A LUCE UNICA CON CHIAMATA DAL CAPOSTAZIONE
   TRAMITE PULSANTE. IL PROGRAMMA E' DOTATO ANCHE DI UN PULSANTE, IL QUALE INTERROMPE IL FUNZIONAMENTO IN CASO DI PERICOLO */

int pulsante_semaforoStazione = 12;// il pulsante che controlla il semaforo a luce unica sulla banchina della stazione
int ledRosso_rgb = 7, ledVerde_rgb = 6;// ledBlu = 5;il led rgb rappresenta il semaforo sulla banchina che emette due colori (rosso o verde)
long millisNOW2, millisOLD2 = millis();/* millisNOW sono i millisecondi attuali, mentre millisOLD quelli passati. Quest'ultimi
  rappresentano i millisecondi che arduino deve aspettare per poi leggere il pulsante, in modo da attivare o disattivare il
  semaforo della stazione */
long int2 = 2000;/* è il tempo di attesa di 2 sec, che impiega per verif. se il tasto è stato premuto o non è stato premuto, evitandone
i rimbalzi (il debounce) */

/* IN CASO DI ALLARME */
int pulsanteAllarme = 9;// è il pulsante che ferma il programma in caso di pericolo
int stato_pulsanteAllarme = LOW;/* controlla se il pulsante che interrompe il programma è stato
premuto così da attivare l'allarme ed interromperne l'esecuzione (ovviamente se HIGH l'allarme è attivo) */
long millisNOW02, millisOLD02 = millis();/* i millisecondi di rif. rappresentano i millisecondi che arduino deve aspettare per verificare se
il tasto è premuto, in modo da attivare l'allarme */
long int02 = 200;/* il tempo di attesa di 0,2 sec che arduino deve attendere per verificare se il tasto è premuto ed attivare così l'allarme,
evitandone i rimbalzi */

/* FUNZIONAMENTO DEI DUE SEMAFORI */
// Semaforo dello scambio (retto deviato)*/
int rosso_rettoDeviato = 8;
int verde_rettoDeviato = 11;

// Semaforo sul tratto dritto (retto tracciato)
int rosso_rettoTracciato = 3;
int verde_rettoTracciato = 5;

int statoSemaf_trattoDritto = HIGH;/* verifica se il semaforo sul tratto dritto è alto o basso.Se è alto(HIGH), si può procedere diritto,
se è basso(LOW), allora si devia il percorso */
long millisNOW50, millisOLD50 = millis();//millisNOW sono i millisecondi attuali, mentre millisOLD quelli passati
long int50 = 50000;// è il tempo di attesa di 50 sec che deve passare per fare lo switch (riferito al tempo di attesa tra i due semafori)

void setup() {
  /* 1) Attiviamo il monitor seriale per vedere ciò che accade su arduino, e verificarne così
     il comportamento dei tre semafori */
  Serial.begin(9600);
  
  /* 2) Configuriamo i due pulsanti come pin di ingresso, utilizzando la resistenza interna
     di arduino. E quindi di conseguenza il funzionamento del pulsante è inverso */
  pinMode(pulsante_semaforoStazione, INPUT_PULLUP);
  pinMode(pulsanteAllarme, INPUT_PULLUP);
  
  /* 3) Configuriamo i due pin del led rgb come pin di uscita. Quest'ultimo rappresenta il semaforo
     a luce unica, della stazione */
  pinMode(ledRosso_rgb, OUTPUT);
  pinMode(ledVerde_rgb, OUTPUT);
  //pinMode(ledBlu, OUTPUT);

  /* 4) Configuro i 4 led per l'accensione dei due semafori, come pin di uscita inquanto, ricevono
     il segnale tramite arduino */
  pinMode(rosso_rettoDeviato, OUTPUT);
  pinMode(verde_rettoDeviato, OUTPUT);
  pinMode(rosso_rettoTracciato, OUTPUT);
  pinMode(verde_rettoTracciato, OUTPUT);
  
  // parto accendendo il verde nel tratto diritto ed il rosso nel tratto deviato
  digitalWrite(rosso_rettoTracciato, LOW);
  digitalWrite(verde_rettoTracciato, HIGH);
  digitalWrite(rosso_rettoDeviato, HIGH);
  digitalWrite(verde_rettoDeviato, LOW);

  /*Inizialmente è verde la luce nel tratto dritto(quindi statoSemaf_trattoDritto = HIGH) e la luce del semaforo a luce unica della stazione, 
    quindi il treno può andare*/
  Serial.println("luce verde ON");
  Serial.print("Tratto dritto: ");
  Serial.println("via libera");
  Serial.println("Aspetta 50 sec");
}

void Funzionamento_Pulsante_allarme() {
/* In questa funzione verifico se sono passati 0,2 sec per poi attivare il pulsante di allarme. Quindi memorizzo il n. di millisecondi
 * attuali nella variabile millisNOW02, verifico se sono passati, dopodichè modifico lo stato del pulsante se è disattivato lo attiva 
 * o viceversa. Poi registro che sono passati 200 msec nella variabile millisOLD02 */
  millisNOW02 = millis();
  if ((millisNOW02 - millisOLD02) >= int02) {
    stato_pulsanteAllarme = !stato_pulsanteAllarme;
    millisOLD02 = millis();
  }
}

void Spegniled_2_semafori() {
// In questa funzione andiamo a spegnere i led che comandano i due semafori
  digitalWrite(rosso_rettoTracciato, LOW);
  digitalWrite(verde_rettoTracciato, LOW);
  digitalWrite(rosso_rettoDeviato, LOW);
  digitalWrite(verde_rettoDeviato, LOW);
}


void Funzionamento_Pulsante_semaforo_stazione() {
/* In questa funzione memorizzo il n. di millisecondi attuali. Verifico se sono passati 2 sec, dopodichè accendo la luce 
 *  rossa del semaforo sulla stazione e spengo i due semafori. Resto in questa condizione per 60 sec, dopodichè riaccendo la luce
 *  verde, non ci sono più passeggeri sulla stazione e quindi il treno può ripartire. Alla fine memorizzo i sec passati nella variabile
 *  millisOLD2 */
  millisNOW2 = millis();
  if ((millisNOW2 - millisOLD2) >= int2) {
    millisOLD2 = millis();
    Serial.println("Luce rossa ON - fermati");
    digitalWrite(ledVerde_rgb, LOW);
    digitalWrite(ledRosso_rgb, HIGH);
    Spegniled_2_semafori();
    Serial.println("Aspetta 60 sec");
    delay(60000);
    digitalWrite(ledRosso_rgb, LOW);
    digitalWrite(ledVerde_rgb, HIGH);
    Serial.println("Luce verde ON - via");
  }
}



void loop() {
  
// 1) Verifico se il pulsante è stato premuto (! poichè risulta premuto quando il suo valore è LOW) dopodichè, esegui la funzione 
  if (!digitalRead(pulsanteAllarme))  Funzionamento_Pulsante_allarme();
// Se il tasto è stato premuto, interrompiamo l'esecuzione, attivando l'allarme (con stato = HIGH), spegnendo anche i semafori
  if (stato_pulsanteAllarme == HIGH) {
    Serial.println("INTERROMPI TUTTO");
    digitalWrite(ledRosso_rgb, LOW);
    digitalWrite(ledVerde_rgb, LOW);
    Spegniled_2_semafori();
   
// Altrimenti se va tutto bene riprendiamo l'esecuzione, disattivando l'allarme (con stato = LOW) 
  } else if (stato_pulsanteAllarme == LOW) {

// 2)Verifico se il pulsante del semaforo della stazione è premuto, dopodichè esegui la funzione
    if (!digitalRead(pulsante_semaforoStazione))  Funzionamento_Pulsante_semaforo_stazione();
    else // altrimenti se non è stato premuto
      digitalWrite(ledVerde_rgb, HIGH);// riaccendi la luce verde 
    //millisNOW50 = millis();// memorizzo il numero di millisecondi che passano nella variabile millisNOW(cioè quelli attuali)
    // Se è solo se sono passati 50 sec (ovvero 50msec)?, entra nella condizione
    if ((millisNOW50 - millisOLD50) >= int50) {
      // Se statoSemaforo è alto procedi diritto, con luce verde e via impedita(con luce rossa) nel tratto deviato
      if (statoSemaf_trattoDritto == HIGH) {
        statoSemaf_trattoDritto = LOW;
        Serial.print("Tratto deviato: ");
        Serial.println("via libera");
        Serial.println("Aspetta 50 sec");
        digitalWrite(verde_rettoTracciato, LOW);
        digitalWrite(rosso_rettoDeviato, LOW);
        digitalWrite(rosso_rettoTracciato, HIGH);
        digitalWrite(verde_rettoDeviato, HIGH);

        // altrimenti se statoSemaforo è basso procedi verso la deviazione, con luce verde e via impedita(con luce rossa) nel tratto diritto
      } else if (statoSemaf_trattoDritto == LOW) {
        statoSemaf_trattoDritto = HIGH;
        Serial.print("Tratto dritto: ");
        Serial.println("via libera");
        Serial.println("Aspetta 50 sec");
        digitalWrite(rosso_rettoTracciato, LOW);
        digitalWrite(verde_rettoDeviato, LOW);
        digitalWrite(verde_rettoTracciato, HIGH);
        digitalWrite(rosso_rettoDeviato, HIGH);
      }
      millisOLD50 = millis();// memorizza i millisecondi che sono passati in questo momento, nella variabile millisOLD50(millisecondi vecchi)
    }// altrimenti aspetta
  }
}