// Definindo as portas dos LEDs
#define LED1 22  //LED1 LARANJA
#define LED2 23  //LED2 LARANJA
#define LED3 24  //LED3 LARANJA
#define LED4 25  //LED4 VERMELHO A
#define LED5 26  //LED5 VERMELHO A
#define LED6 27  //LED6 VERMELHO A
#define LED7 28  //LED7 AZUL
#define LED8 29  //LED8 VERMELHO B
#define LED9 30  //LED9 VERMELHO B
#define LED10 31  //LED10 VERMELHO B
#define LED11 32  //LED11 AMARELO
#define LED12 33  //LED12 AMARELO
#define LED13 34  //LED13 AMARELO
#define LED14 35  //LED14 VERDE A
#define LED15 36  //LEDS15 AZUIS DUPLOS
#define LED16 37  //LEDS16 AZUIS DUPLOS
#define LED17 38  //LEDS17 AZUIS DUPLOS
#define LED18 39  //LEDS18 AZUIS DUPLOS
#define LED19 40  //LED19 VERDE B
#define LED20 41  //LED20 VERDE B
#define LED21 42  //LED21 VERDE B
#define LED22 43  //LED22 VERDE B
#define LED23 44  //LED23 VERDE B



// Definindo o intervalo de acionamento dos LEDs sequenciais
unsigned long intervalo_sequencial = 500;
unsigned long anterior_sequencial = 0;
int led_atual = 1;

// Definindo o intervalo de acionamento dos LEDs sequenciais VERMELHO B
unsigned long intervalo_sequencial_b = 200;
unsigned long anterior_sequencial_b = 0;
int led_atual_b = 7;

// Definindo o intervalo de acionamento dos LEDs sequenciais AZUIS DUPLOS
unsigned long intervalo_sequencial_d = 100;
unsigned long anterior_sequencial_d = 0;
int led_atual_d = 10;




// Definindo o intervalo de acionamento dos LEDs VERMELHOS 1
unsigned long intervalo_duplo = 300;
unsigned long anterior_duplo = 0;
int led_duplo_atual = 4;
int contagem_duplo = 0;

// Definindo o intervalo de acionamento dos LEDs AMARELOS
unsigned long intervalo_duplo_c = 100;
unsigned long anterior_duplo_c = 0;
int led_duplo_atual_c = 7;
int contagem_duplo_c = 0;


// Definindo o intervalo de acionamento dos LEDs VERDES B------------------
unsigned long intervalo_duplo_d = 20;
unsigned long anterior_duplo_d = 0;
int led_duplo_atual_d = 13;
int contagem_duplo_d = 0;




// EU - Definindo o intervalo de acionamento do LED azul
// Define a duração do intervalo do LED em milissegundos
int intervaloLedAzul = 150; // 0,2 segundos
// Define a duração do intervalo de pausa do LED em milissegundos
int intervaloPausaAzul = 400; // 1 segundo
// Variável para armazenar o tempo atual
unsigned long tempoAtualAzul = 0;
// Variável para armazenar o último tempo em que o LED mudou de estado
unsigned long tempoUltimoLedAzul = 0;
// Variável para armazenar o estado atual do LED
int estadoLedAzul = LOW;



// EU - Definindo o intervalo de acionamento do LED VERDE 
// Define a duração do intervalo do LED em milissegundos
int intervaloLedVerde = 250; // 0,2 segundos
// Define a duração do intervalo de pausa do LED em milissegundos
int intervaloPausaVerde = 400; // 1 segundo
// Variável para armazenar o tempo atual
unsigned long tempoAtualVerde = 0;
// Variável para armazenar o último tempo em que o LED mudou de estado
unsigned long tempoUltimoLedVerde = 0;
// Variável para armazenar o estado atual do LED
int estadoLedVerde = LOW;


//FUNÇÃO DOS BOTÕES DOS RELES
const int button1Pin = 50;   // Pino do botão 1
const int button2Pin = 51;   // Pino do botão 2
const int relay1Pin = 45;    // Pino do relé 1
const int relay2Pin = 46;    // Pino do relé 2

bool button1State = false;  // Estado atual do botão 1
bool button2State = false; //false;  // Estado atual do botão 2
bool relay1State = false;//false;   // Estado atual do relé 1
bool relay2State = false;//false;   // Estado atual do relé 2

unsigned long lastDebounceTime1 = 0;  // Último tempo de debounce para o botão 1
unsigned long debounceDelay1 = 50;    // Delay de debounce

unsigned long lastDebounceTime2 = 0;  // Último tempo de debounce para o botão 1
unsigned long debounceDelay2 = 50;    // Delay de debounce












void setup() {
  // Configurando as portas dos LEDs como saída
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  pinMode(LED5, OUTPUT);
  pinMode(LED6, OUTPUT);
  pinMode(LED7, OUTPUT);
  pinMode(LED8, OUTPUT);
  pinMode(LED9, OUTPUT);
  pinMode(LED10, OUTPUT);
  pinMode(LED11, OUTPUT);
  pinMode(LED12, OUTPUT);
  pinMode(LED13, OUTPUT);
  pinMode(LED14, OUTPUT);
  pinMode(LED15, OUTPUT);
  pinMode(LED16, OUTPUT);
  pinMode(LED17, OUTPUT);
  pinMode(LED18, OUTPUT);
  pinMode(LED19, OUTPUT);
  pinMode(LED20, OUTPUT);
  pinMode(LED21, OUTPUT);
  pinMode(LED22, OUTPUT);
  pinMode(LED23, OUTPUT);


  //pinMode(50, INPUT_PULLUP);
  //pinMode(51, INPUT_PULLUP);

  pinMode(button1Pin, INPUT_PULLUP);  // Configura o pino do botão 1 como entrada com pull-up
  pinMode(button2Pin, INPUT_PULLUP);  // Configura o pino do botão 2 como entrada com pull-up
  pinMode(relay1Pin, OUTPUT);         // Configura o pino do relé 1 como saída
  pinMode(relay2Pin, OUTPUT);         // Configura o pino do relé 2 como saída



  




}



















void loop() {
  // Obtendo o tempo atual
  unsigned long atual = millis();
  unsigned long atual_b = millis();
  unsigned long atual_c = millis();
  unsigned long atual_d = millis();

  


  // Checando se o intervalo de acionamento do LED atual foi alcançado
  if (atual - anterior_sequencial >= intervalo_sequencial) {
    // Invertendo o estado do LED atual
    switch(led_atual) {
      case 1:
        digitalWrite(LED1, !digitalRead(LED1));
        led_atual = 2;
        break;
      case 2:
        digitalWrite(LED2, !digitalRead(LED2));
        led_atual = 3;
        break;
      case 3:
        digitalWrite(LED3, !digitalRead(LED3));
        led_atual = 1;
        break;
    }
    // Atualizando o valor de anterior_sequencial
    anterior_sequencial = atual;
  }

  // Checando se o intervalo de acionamento dos LEDs duplos foi alcançado
  if (atual - anterior_duplo >= intervalo_duplo) {
    // Invertendo o estado do LED duplo atual
    switch(led_duplo_atual) {
      case 4:
        if (contagem_duplo < 2) {
          digitalWrite(LED4, HIGH);
          contagem_duplo++;
        } else {
          digitalWrite(LED4, LOW);
          led_duplo_atual = 5;
          contagem_duplo = 0;
        }
        break;
      case 5:
        if (contagem_duplo < 2) {
          digitalWrite(LED5, HIGH);
          contagem_duplo++;
        } else {
          digitalWrite(LED5, LOW);
          led_duplo_atual = 6;
          contagem_duplo = 0;
        }
        break;
      case 6:
        if (contagem_duplo < 2) {
          digitalWrite(LED6, HIGH);
          contagem_duplo++;
        } else {
          digitalWrite(LED6, LOW);
          led_duplo_atual = 4;
          contagem_duplo = 0;
        }
        break;
    }
    // Atualizando o valor de anterior_duplo
    anterior_duplo = atual;
  }
   
   
    // EU -  Lê o tempo atual em milissegundos
    tempoAtualAzul = millis();

  // Verifica se o tempo atual é maior ou igual ao último tempo em que o LED mudou de estado
  if (tempoAtualAzul - tempoUltimoLedAzul >= (estadoLedAzul == HIGH ? intervaloLedAzul : intervaloPausaAzul)) {
    // Atualiza o tempo do último estado do LED
    tempoUltimoLedAzul = tempoAtualAzul;

    // Alterna o estado do LED
    estadoLedAzul = estadoLedAzul == HIGH ? LOW : HIGH;

    // Define o estado do LED
    digitalWrite(LED7, estadoLedAzul);
  }

// Checando se o intervalo de acionamento do LED VERMELHO_b atual_b foi alcançado
  if (atual_b - anterior_sequencial_b >= intervalo_sequencial_b) {
    // Invertendo o estado do LED atual_b
    switch(led_atual_b) {
      case 7:
        digitalWrite(LED8, !digitalRead(LED8));
        led_atual_b = 8;
        break;
      case 8:
        digitalWrite(LED9, !digitalRead(LED9));
        led_atual_b = 9;
        break;
      case 9:
        digitalWrite(LED10, !digitalRead(LED10));
        led_atual_b = 7;
        break;
    }
    // Atualizando o valor de anterior_sequencial
    anterior_sequencial_b = atual_b;
  }



// Checando se o intervalo de acionamento dos LEDs AMARELOS foi alcançado
  if (atual_c - anterior_duplo_c >= intervalo_duplo_c) {
    // Invertendo o estado do LED duplo atual
    switch(led_duplo_atual_c) {
      case 7: //4
        if (contagem_duplo_c < 2) {
          digitalWrite(LED11, HIGH);
          contagem_duplo_c++;
        } else {
          digitalWrite(LED11, LOW);
          led_duplo_atual_c = 8;
          contagem_duplo_c = 0;
        }
        break;
      case 8: //5
        if (contagem_duplo_c < 2) {
          digitalWrite(LED12, HIGH);
          contagem_duplo_c++;
        } else {
          digitalWrite(LED12, LOW);
          led_duplo_atual_c = 9;
          contagem_duplo_c = 0;
        }
        break;
      case 9: //6
        if (contagem_duplo_c < 2) {
          digitalWrite(LED13, HIGH);
          contagem_duplo_c++;
        } else {
          digitalWrite(LED13, LOW);
          led_duplo_atual_c = 7;
          contagem_duplo_c = 0;
        }
        break;
    }
    // Atualizando o valor de anterior_duplo_c
    anterior_duplo_c = atual_c;
  }



 // EU -  Lê o tempo atual em milissegundos LED VERDE
    tempoAtualVerde = millis();

  // Verifica se o tempo atual é maior ou igual ao último tempo em que o LED mudou de estado
  if (tempoAtualVerde - tempoUltimoLedVerde >= (estadoLedVerde == HIGH ? intervaloLedVerde : intervaloPausaVerde)) {
    // Atualiza o tempo do último estado do LED
    tempoUltimoLedVerde = tempoAtualVerde;

    // Alterna o estado do LED
    estadoLedVerde = estadoLedVerde == HIGH ? LOW : HIGH;

    // Define o estado do LED
    digitalWrite(LED14, estadoLedVerde);
  }



// Checando se o intervalo de acionamento do LED atual_d foi alcançado
  if (atual_d - anterior_sequencial_d >= intervalo_sequencial_d) {
    // Invertendo o estado do LED atual_c
    switch(led_atual_d) {
      case 10:
        digitalWrite(LED15, !digitalRead(LED15));
        led_atual_d = 11;
        break;
      case 11:
        digitalWrite(LED16, !digitalRead(LED16));
        led_atual_d = 12;
        break;
      case 12:
        digitalWrite(LED17, !digitalRead(LED17));
        led_atual_d = 13;
        break;
      case 13:
        digitalWrite(LED18, !digitalRead(LED18));
        led_atual_d = 10;
        break;
    }
    // Atualizando o valor de anterior_sequencial
    anterior_sequencial_d = atual_d;
  }


// Checando se o intervalo de acionamento dos LEDs VERDES FINAIS foi alcançado
  if (atual_d - anterior_duplo_d >= intervalo_duplo_d) {
    // Invertendo o estado do LED duplo atual
    switch(led_duplo_atual_d) {
      case 13:
        if (contagem_duplo_d < 2) {
          digitalWrite(LED19, HIGH);
          contagem_duplo_d++;
        } else {
          digitalWrite(LED19, LOW);
          led_duplo_atual_d = 14;
          contagem_duplo_d = 0;
        }
        break;
      case 14:
        if (contagem_duplo_d < 2) {
          digitalWrite(LED20, HIGH);
          contagem_duplo_d++;
        } else {
          digitalWrite(LED20, LOW);
          led_duplo_atual_d = 15;
          contagem_duplo_d = 0;
        }
        break;
      case 15:
        if (contagem_duplo_d < 2) {
          digitalWrite(LED21, HIGH);
          contagem_duplo_d++;
        } else {
          digitalWrite(LED21, LOW);
          led_duplo_atual_d = 16;
          contagem_duplo_d = 0;
        }
        break;
      case 16:
        if (contagem_duplo_d < 2) {
          digitalWrite(LED22, HIGH);
          contagem_duplo_d++;
        } else {
          digitalWrite(LED22, LOW);
          led_duplo_atual_d = 17;
          contagem_duplo_d = 0;
        }
        break;
      case 17:
        if (contagem_duplo_d < 2) {
          digitalWrite(LED23, HIGH);
          contagem_duplo_d++;
        } else {
          digitalWrite(LED23, LOW);
          led_duplo_atual_d = 13;
          contagem_duplo_d = 0;
        }
        break;
    }
    // Atualizando o valor de anterior_duplo_c
    anterior_duplo_d = atual_d;
  }

  //PROGRAMAÇÃO DOS BOTÕES E RELES---------------------------------------
  // Lê o estado do botão 1 e atualiza o estado do relé 1
  int reading1 = !digitalRead(button1Pin);
   if (reading1 != button1State) {
    lastDebounceTime1 = millis();
  }
   if ((millis() - lastDebounceTime1) > debounceDelay1) {
    if (reading1 != relay1State) {
      relay1State = reading1;
      digitalWrite(relay1Pin, relay1State);
    }
  }
  button1State = reading1;



  // Lê o estado do botão 2 e atualiza o estado do relé 2
  int reading2 = !digitalRead(button2Pin);
   if (reading2 != button2State) {
    lastDebounceTime2 = millis();
  }
  if ((millis() - lastDebounceTime2) > debounceDelay2) {
    if (reading2 != relay2State) {
      relay2State = reading2;
      digitalWrite(relay2Pin, relay2State);
    }
  }
  button2State = reading2;




}