// Pines de entrada
const int conmutadorLlenado = 2;      // (Real) Conmutador para habilitar FSM1 (llenado/vaciado). HIGH = habilitado.
const int conmutadorCalibracion = 3; // (Real) Conmutador para habilitar FSM2 (calibración). HIGH = habilitado.

// Pines de salida
const int habilitarLlenado = 4;      // (Real) Salida para habilitar FSM1.
const int habilitarCalibracion = 5; // (Real) Salida para habilitar FSM2.

// Definición de los estados de la FSM
enum Estado {
  ESPERA,                // Estado inicial. No hay FSM activas.
  LLENADO_VACIADO,       // FSM1 activa. Se está realizando llenado/vaciado.
  CALIBRACION,           // FSM2 activa. Se está realizando calibración.
  PRIORIDAD_CALIBRACION  // FSM2 activa con prioridad. FSM1 se suspende temporalmente.
};

// Variable para almacenar el estado actual
Estado estadoActual = ESPERA;

void setup() {
  // Configurar los pines de entrada
  pinMode(conmutadorLlenado, INPUT);       // Configurar el pin del conmutador de llenado como entrada.
  pinMode(conmutadorCalibracion, INPUT);  // Configurar el pin del conmutador de calibración como entrada.

  // Configurar los pines de salida
  pinMode(habilitarLlenado, OUTPUT);      // Configurar el pin de habilitación de FSM1 como salida.
  pinMode(habilitarCalibracion, OUTPUT);  // Configurar el pin de habilitación de FSM2 como salida.

  // Inicializar las salidas en LOW (inactivas al inicio)
  digitalWrite(habilitarLlenado, LOW);
  digitalWrite(habilitarCalibracion, LOW);

  // Inicializar la comunicación serial para depuración
  Serial.begin(9600);
}

void loop() {
  // Leer el estado de los conmutadores
  bool CL = digitalRead(conmutadorLlenado);       // Leer el conmutador de llenado (FSM1).
  bool CC = digitalRead(conmutadorCalibracion);  // Leer el conmutador de calibración (FSM2).

  // Máquina de estados finita (FSM) principal
  switch (estadoActual) {
    case ESPERA: // Estado inicial. No hay FSM activas.
      if (CL && !CC) { // Si se activa FSM1 y FSM2 no está habilitada.
        estadoActual = LLENADO_VACIADO;           // Cambiar al estado de llenado/vaciado.
        digitalWrite(habilitarLlenado, HIGH);     // Activar FSM1.
      } else if (CC) { // Si se activa FSM2.
        estadoActual = CALIBRACION;              // Cambiar al estado de calibración.
        digitalWrite(habilitarCalibracion, HIGH); // Activar FSM2.
      }
      break;

    case LLENADO_VACIADO: // FSM1 activa. Llenado/vaciado en proceso.
      if (CC) { // Si se solicita FSM2 mientras FSM1 está activa.
        estadoActual = PRIORIDAD_CALIBRACION;    // Cambiar al estado de prioridad de calibración.
        digitalWrite(habilitarLlenado, LOW);     // Suspender FSM1.
        digitalWrite(habilitarCalibracion, HIGH);// Activar FSM2.
      } else if (!CL) { // Si FSM1 se desactiva.
        estadoActual = ESPERA;                   // Volver al estado de espera.
        digitalWrite(habilitarLlenado, LOW);     // Desactivar FSM1.
      }
      break;

    case CALIBRACION: // FSM2 activa. Calibración en proceso.
      if (!CC) { // Si FSM2 se desactiva.
        estadoActual = ESPERA;                   // Volver al estado de espera.
        digitalWrite(habilitarCalibracion, LOW); // Desactivar FSM2.
      }
      break;

    case PRIORIDAD_CALIBRACION: // FSM2 tiene prioridad. FSM1 suspendida temporalmente.
      if (!CC) { // Si FSM2 se desactiva.
        estadoActual = LLENADO_VACIADO;          // Retomar FSM1.
        digitalWrite(habilitarCalibracion, LOW); // Desactivar FSM2.
        digitalWrite(habilitarLlenado, HIGH);    // Reactivar FSM1.
      }
      break;
  }

  // Imprimir el estado actual en el monitor serial
  Serial.print("Estado actual: ");
  switch (estadoActual) {
    case ESPERA:                Serial.println("ESPERA"); break;
    case LLENADO_VACIADO:       Serial.println("LLENADO_VACIADO"); break;
    case CALIBRACION:           Serial.println("CALIBRACION"); break;
    case PRIORIDAD_CALIBRACION: Serial.println("PRIORIDAD_CALIBRACION"); break;
  }

  delay(100); // Pequeño retraso para evitar rebotes en los interruptores.
}


// Maquina de estado # 3 Sincronizacion
//Estado (S) |	conmutadorLlenado (CL) |	conmutadorCalibracion(CC)|	Siguiente Estado (S)|	habilitarLlenado |	habilitarCalibracion
//    0	     |          0	             |            0	             |        0	              |        0	       |            0
//    0      |          1	             |            0	             |        1	              |        1	       |            0
//    0      |          0	             |            1	             |        2	              |        0	       |            1
//    0      |          1	             |            1	             |        2	              |        0	       |            1
//    1	     |          0	             |            1	             |        2	              |        0	       |            1
//    1	     |          0	             |            0	             |        0	              |        0	       |            0
//    2	     |          X	             |            0	             |        0	              |        0	       |            0
//    3	     |          X	             |            0	             |        1	              |        1	       |            0