// Koller Code
// 07/09/2024

//Objetivo

//Este código controla quatro motores conectados aos pinos Pin13, Pin12, Pin11 e Pin10 de um 
//microcontrolador (como um Arduino). O controle dos motores pode ser feito de forma 
//manual, pressionando botões conectados aos pinos PinA1, PinA2, PinA3, e 
//PinA4, ou de forma automática, gerando 180 pulsos a cada 60 segundos.

//Funcionamento

//Setup Inicial: No setup(), os pinos dos motores são configurados como saídas (OUTPUT), e 
//os pinos dos botões são configurados como entradas com pull-up (INPUT_PULLUP), o que 
//significa que os botões estão normalmente em estado HIGH até serem pressionados
//(ficando LOW).

//Pausa e Controle Manual:

//Um botão de pausa está conectado ao pino A5. Se o botão de pausa for pressionado 
//(pausa == true), os motores só giram enquanto seus respectivos botões estão 
//pressionados.
//Quando o botão é solto, o motor para de girar.

//Controle Automático:

//Se a pausa não está ativada, o código entra no modo automático. Cada motor gera 180 
//pulsos (usando a função cicloMotor()) e repete o ciclo a cada 60 segundos.
//O ciclo de pulsos controla o motor, ativando-o e desativando-o em intervalos curtos,
//repetindo isso 180 vezes.
//Funções:

//cicloMotor(): Gera pulsos curtos para os motores, mantendo o controle da contagem de 
//pulsos e reiniciando o ciclo após 180 pulsos.
//comtinuo(): Utilizado no modo manual, envia pulsos contínuos ao motor enquanto o 
//botão correspondente estiver pressionado.

//Comportamento Geral

//Quando em pausa: O motor só gira quando o botão específico está pressionado.
//Quando não em pausa: O motor gira automaticamente 180 pulsos e espera 60 segundos
//antes de repetir o ciclo.

//Principais Variáveis

//contagemPulso: Contagem dos pulsos para cada motor.
//tempoUltimoCiclo: Controla o tempo decorrido desde o último ciclo de 180 pulsos, para 
//garantir o intervalo de 60 segundos entre os ciclos.
//pausa: Indica se o sistema está em modo de pausa ou não.
//Isso permite controlar os motores tanto de forma manual quanto automática com um
//ciclo definido.



const int Pin1 = 13;
const int Pin2 = 12;
const int Pin3 = 11;
const int Pin4 = 10;
const int modoPin1 = A1;
const int modoPin2 = A2;
const int modoPin3 = A3;
const int modoPin4 = A4;
const int pausaPin = A5; // Adiciona o pino de pausa
const int pulso = 180; // Número de pulsos para o motor
const int intervaloPulso = 2; // Tempo entre os pulsos em milissegundos
const unsigned long tempoEspera = 60000; // Tempo entre ciclos em milissegundos

unsigned long tempoUltimoCiclo1 = 0;
unsigned long tempoUltimoCiclo2 = 0;
unsigned long tempoUltimoCiclo3 = 0;
unsigned long tempoUltimoCiclo4 = 0;

unsigned long tempoUltimoPulso1 = 0;
unsigned long tempoUltimoPulso2 = 0;
unsigned long tempoUltimoPulso3 = 0;
unsigned long tempoUltimoPulso4 = 0;

int contagemPulso1 = 0;
int contagemPulso2 = 0;
int contagemPulso3 = 0;
int contagemPulso4 = 0;

bool pausa = false; // Variável para indicar se está em pausa
bool ultimaPausa = false; // Variável para lembrar o estado anterior do pino de pausa

void setup() {
  pinMode(Pin1, OUTPUT);
  pinMode(modoPin1, INPUT_PULLUP);
  pinMode(Pin2, OUTPUT);
  pinMode(modoPin2, INPUT_PULLUP);
  pinMode(Pin3, OUTPUT);
  pinMode(modoPin3, INPUT_PULLUP);
  pinMode(Pin4, OUTPUT);
  pinMode(modoPin4, INPUT_PULLUP);
  pinMode(pausaPin, INPUT_PULLUP); // Configura o pino de pausa como entrada com pull-up
}

void loop() {
  // Verifica se deve pausar (sinal invertido)
  bool estadoAtualPausa = (digitalRead(pausaPin) == HIGH);

  if (pausa && !estadoAtualPausa) {
    // Quando a pausa é desfeita, zera o tempo dos ciclos e a contagem de pulsos
    tempoUltimoCiclo1 = millis();
    tempoUltimoCiclo2 = millis();
    tempoUltimoCiclo3 = millis();
    tempoUltimoCiclo4 = millis();

    contagemPulso1 = 0;
    contagemPulso2 = 0;
    contagemPulso3 = 0;
    contagemPulso4 = 0;
  }

  pausa = estadoAtualPausa;
  ultimaPausa = estadoAtualPausa;

  if (pausa) {
    // Controle manual durante a pausa
    if (digitalRead(modoPin1) == LOW) {
      comtinuo(Pin1); // Gira o motor enquanto o botão estiver pressionado
    } else {
      digitalWrite(Pin1, LOW); // Para o motor quando o botão é solto
    }

    if (digitalRead(modoPin2) == LOW) {
      comtinuo(Pin2);
    } else {
      digitalWrite(Pin2, LOW);
    }

    if (digitalRead(modoPin3) == LOW) {
      comtinuo(Pin3);
    } else {
      digitalWrite(Pin3, LOW);
    }

    if (digitalRead(modoPin4) == LOW) {
      comtinuo(Pin4);
    } else {
      digitalWrite(Pin4, LOW);
    }

  } else {
    // Controle automático quando não está em pausa
    unsigned long agora = millis();

    // Motor 1
    if (agora - tempoUltimoCiclo1 >= tempoEspera) {
      cicloMotor(Pin1, contagemPulso1, tempoUltimoPulso1);
      if (contagemPulso1 >= pulso) {
        contagemPulso1 = 0;  // Reinicia a contagem de pulsos após 180
        tempoUltimoCiclo1 = agora; // Reinicia o ciclo de espera de 60 segundos
      }
    }

    // Motor 2
    if (agora - tempoUltimoCiclo2 >= tempoEspera) {
      cicloMotor(Pin2, contagemPulso2, tempoUltimoPulso2);
      if (contagemPulso2 >= pulso) {
        contagemPulso2 = 0;  // Reinicia a contagem de pulsos após 180
        tempoUltimoCiclo2 = agora; // Reinicia o ciclo de espera de 60 segundos
      }
    }

    // Motor 3
    if (agora - tempoUltimoCiclo3 >= tempoEspera) {
      cicloMotor(Pin3, contagemPulso3, tempoUltimoPulso3);
      if (contagemPulso3 >= pulso) {
        contagemPulso3 = 0;  // Reinicia a contagem de pulsos após 180
        tempoUltimoCiclo3 = agora; // Reinicia o ciclo de espera de 60 segundos
      }
    }

    // Motor 4
    if (agora - tempoUltimoCiclo4 >= tempoEspera) {
      cicloMotor(Pin4, contagemPulso4, tempoUltimoPulso4);
      if (contagemPulso4 >= pulso) {
        contagemPulso4 = 0;  // Reinicia a contagem de pulsos após 180
        tempoUltimoCiclo4 = agora; // Reinicia o ciclo de espera de 60 segundos
      }
    }
  }
}

void cicloMotor(int pin, int& contagemPulso, unsigned long& tempoUltimoPulso) {
  unsigned long agora = millis();

  if (agora - tempoUltimoPulso >= intervaloPulso && contagemPulso < pulso) {
    digitalWrite(pin, HIGH);
    delayMicroseconds(100); // Pulso curto
    digitalWrite(pin, LOW);

    tempoUltimoPulso = agora;
    contagemPulso++;
  }
}

void comtinuo(int pin) {
  digitalWrite(pin, HIGH);
  delay(intervaloPulso);
  digitalWrite(pin, LOW);
  delay(intervaloPulso);
}