/*Se desea realizar el control de una barrera que nos brinda acceso a un garaje. Esta barrera es de un
solo carril, y un solo sentido de circulación. También se sabe que ingresa a nuestro sistema de
barrera de un solo vehículo a la vez. El sistema está conformado por dos sensores (S1 y S2), un
motor que controla la barrera, un led de aviso y una alarma. El sistema funciona de la siguiente
manera: Si se detecta un vehículo que desea ingresar (sensor 1) se abre la barrera, la misma tarda
en abrirse 5 segundos y la velocidad del motor de la barrera funciona de la siguiente manera: el
primer segundo funciona al 30%, durante 2 segundos al 70%, y los últimos 2 segundos al 100%.
Cuando ingreso un vehículo, un led parpadeará a razón de 4 veces por segundo. Esto lo hará hasta
que el vehículo toque el sensor 2, lo que indica que está avanzando. Cuando deja de tocar el sensor
2, la barrera comienza a bajar 10 segundos después de que el auto terminó de pasar por dicho
sensor. Si en ese momento se detecta que otro vehículo quiere ingresar (sensor 1), la barrera se
debe mantener elevada hasta que el mismo la cruza (sensor 2), y la cuenta de los 5 segundos se
debe reiniciar. Si un auto ingresa de contramano, habrá una alarma lumínica (usar el indicador
visual), donde dicho led parpadea a razón de 5 veces por segundo (100ms encendido y 100ms
apagado), durante 8 segundos. Al finalizar este tiempo, si el auto no ha salido del sensor 2, se
activará una alarma hasta que salga.*/

enum Estado{
  espera,
  abriendo,
  abierta,
  espcierre,
  cerrando,
  alarmcontra,
  alarmperma
};

#define motor 13
#define  alarm 14
#define indic 15
#define senso 16
#define senso1 17
#define buzzly 21

unsigned long tAnt = 0;
unsigned long tAnth = 0;
unsigned long tAct = 0;
bool lingreso = LOW;
bool lalarm = LOW;

Estado estado = espera;

void setup() {
  pinMode(alarm, OUTPUT);
  pinMode(motor, OUTPUT);
  pinMode(indic, OUTPUT);
  pinMode(senso, INPUT_PULLUP);
  pinMode(senso1, INPUT_PULLUP);
  pinMode(buzzly, OUTPUT);
}

void loop() {
  bool S1 = digitalRead(senso);
  bool S2 = digitalRead(senso1);

  tAct = millis();

  switch(estado){

    case (espera): 

    if(S2 == LOW){

      tAnt = millis();
      estado = alarmcontra;

    }
    
    if(S1 == LOW){
      tAnt = millis();
      estado = abriendo;

    } break;

    case (abriendo):

    if(tAct - tAnt <= 1000){
      analogWrite(motor, 76);
    }
    else if(tAct - tAnt <= 3000){
      analogWrite(motor, 179);
    }
    else if(tAct - tAnt <= 5000){
      analogWrite(motor, 255);
    }
    else if(tAct - tAnt >= 5000){
      analogWrite(motor, 0);
      estado = abierta;
    }
    
    break;

    case (abierta):

    if(S2 == HIGH){
    if(tAct - tAnt >= 250){
      tAnt = millis();
      lingreso = !lingreso;
      digitalWrite(indic, lingreso);
    }
    }

    if(S2 == LOW){
      digitalWrite(indic, LOW);
      tAnt = millis();
      estado = espcierre;
    }
  break;

  case (espcierre):


      if(S2 == HIGH){
        tAnt = millis();

        if(S1 == HIGH && tAnt >= 10000){

          analogWrite(motor, 255);
          estado = espera;

        }
        if(S1 == LOW && tAnt < 10000){
          tAnt = millis();
          estado = abierta;
        }
      }
      break;
  
  case (alarmcontra):

  tAnt = millis();

  if(tAct - tAnth <= 200 && tAct - tAnt < 8000){
    tAnth = millis();
    lalarm = !lalarm;
    digitalWrite(indic, lalarm);
  }

  if(S2 == HIGH && tAnt <= 8000){
    tAnt = millis();
    
    estado = espera;
  }

  if(S2 == LOW && tAnt >= 8000){
    tAnt = millis();
    estado = alarmperma;
  } break;

  case (alarmperma):

  if(S2 == HIGH){
    digitalWrite(buzzly, HIGH);
  }
  else{
    digitalWrite(buzzly, LOW);
    estado = espera;
  }
  break;
  }
}