Estacionamiento Automatizado

// Estacionamiento automatizado — Nivel Inicial (Arduino UNO).
//
// Maqueta a escala de un estacionamiento de 8 plazas con DOS barreras:
//   - Barrera de ENTRADA: un pulsador la abre (servo a 90) SOLO si quedan
//     lugares; al pasar el auto, se cierra y se resta un lugar.
//   - Barrera de SALIDA: un pulsador la abre; al salir el auto, se cierra y
//     se suma un lugar.
// Dos LED indican de un vistazo la ocupacion, como pide la situacion-problema
// de Juana:  VERDE = hay lugar,  ROJO = estacionamiento completo.
//
// Plataforma: Arduino UNO. Proyecto de BAJA TENSION (servos 5 V, LED,
// pulsadores): no hay 220 V ni agua, no lleva advertencias electricas.
//
// Nivel inicial: se permite delay() (fiel a la progresion del original).
//
// Basado en: Fragmentos de codigo del Nivel Inicial (Pasos 2, 4 y 5) —
// Estacionamiento Automatizado, Saberes Digitales (INET/EDUCAR 2019).
// CORRECCION DE BUG CRITICO (ver README):
//   El original ataba servoEntrada al pin 0 y servoSalida al pin 1. Los pines
//   0 y 1 del UNO son el RX/TX del USB/serial de programacion: usarlos para
//   los servos ROMPE la carga del sketch y el Monitor Serie. Se remapean a
//   los pines 4 (entrada) y 8 (salida), que estan libres.

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Capacidad del estacionamiento ---
const int CAPACIDAD = 8;

// --- Pines de las barreras (servos) — REMAPEADOS (bug del original) ---
const int PIN_SERVO_ENTRADA = 4;  // original: pin 0 (RX) = BUG, rompe el USB
const int PIN_SERVO_SALIDA  = 8;  // original: pin 1 (TX) = BUG, rompe el USB

// --- Pines de los pulsadores ---
// El original usa resistencias de 10K como PULLDOWN (estan en los insumos):
// el pulsador lee HIGH cuando se presiona y LOW en reposo.
const int PIN_PULSADOR_ENTRADA = 2;
const int PIN_PULSADOR_SALIDA  = 3;

// --- Pines de los LED de estado ---
// Estos dos LED existen SOLO en el nivel inicial. En el nivel intermedio se
// reemplazan por el display de 7 segmentos (que reutiliza estos pines).
const int PIN_LED_VERDE = 9;   // encendido = hay lugares disponibles
const int PIN_LED_ROJO  = 13;  // encendido = estacionamiento completo

// --- Angulos de la barrera ---
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// Tiempo (ms) que se espera, tras liberar el pulsador, a que el auto termine
// de cruzar antes de bajar la barrera.
const unsigned long TIEMPO_PASO_MS = 3000;

// Lugares disponibles. Arranca vacio: 8 lugares libres.
int lugares = CAPACIDAD;

Servo servoEntrada;
Servo servoSalida;

void setup() {
  pinMode(PIN_PULSADOR_ENTRADA, INPUT);
  pinMode(PIN_PULSADOR_SALIDA, INPUT);
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);

  servoEntrada.attach(PIN_SERVO_ENTRADA);
  servoSalida.attach(PIN_SERVO_SALIDA);
  // Ambas barreras arrancan bajas (cerradas).
  servoEntrada.write(ANGULO_CERRADA);
  servoSalida.write(ANGULO_CERRADA);
}

void loop() {
  // --- ENTRADA: solo se abre si hay al menos un lugar libre ---
  if (digitalRead(PIN_PULSADOR_ENTRADA) == HIGH && lugares >= 1) {
    servoEntrada.write(ANGULO_ABIERTA);
    // Mientras el auto sigue sobre el pulsador, esperamos.
    while (digitalRead(PIN_PULSADOR_ENTRADA) == HIGH) {
    }
    delay(TIEMPO_PASO_MS);
    servoEntrada.write(ANGULO_CERRADA);
    lugares = lugares - 1;  // entro un auto: un lugar menos
  }

  // --- SALIDA: solo tiene sentido si hay algun auto adentro (lugares < 8) ---
  // El guard (lugares < CAPACIDAD) evita que el contador supere la capacidad.
  if (digitalRead(PIN_PULSADOR_SALIDA) == HIGH && lugares < CAPACIDAD) {
    servoSalida.write(ANGULO_ABIERTA);
    while (digitalRead(PIN_PULSADOR_SALIDA) == HIGH) {
    }
    delay(TIEMPO_PASO_MS);
    servoSalida.write(ANGULO_CERRADA);
    lugares = lugares + 1;  // salio un auto: un lugar mas
  }

  // --- LED de estado ---
  if (lugares > 0) {
    digitalWrite(PIN_LED_VERDE, HIGH);
    digitalWrite(PIN_LED_ROJO, LOW);
  } else {
    digitalWrite(PIN_LED_VERDE, LOW);
    digitalWrite(PIN_LED_ROJO, HIGH);
  }
}

// Estacionamiento automatizado — Nivel Inicial (ESP32 DevKit v1).
//
// Maqueta a escala de un estacionamiento de 8 plazas con DOS barreras:
//   - Barrera de ENTRADA: un pulsador la abre (servo a 90) SOLO si quedan
//     lugares; al pasar el auto, se cierra y se resta un lugar.
//   - Barrera de SALIDA: un pulsador la abre; al salir el auto, se cierra y
//     se suma un lugar.
// Dos LED indican la ocupacion:  VERDE = hay lugar,  ROJO = completo.
//
// Plataforma: ESP32 (DevKit v1). Servo con la libreria ESP32Servo (la Servo.h
// clasica no funciona en ESP32). Proyecto de BAJA TENSION: sin 220 V ni agua.
// Nota electrica: el ESP32 trabaja a 3,3 V; los servos se alimentan desde 5 V
// con GND comun con la placa.
//
// Nivel inicial: se permite delay() (fiel a la progresion del original).
//
// Basado en: Fragmentos de codigo del Nivel Inicial (Pasos 2, 4 y 5) —
// Estacionamiento Automatizado, Saberes Digitales (INET/EDUCAR 2019).
// Los servos van a GPIO seguros del contrato (25/26); no aplica el bug de los
// pines 0/1 del UNO, pero la eleccion de GPIO evita strapping pins.

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Capacidad del estacionamiento ---
const int CAPACIDAD = 8;

// --- Pines de las barreras (servos) — GPIO del contrato ---
const int PIN_SERVO_ENTRADA = 25;
const int PIN_SERVO_SALIDA  = 26;

// --- Pines de los pulsadores (con resistencia de 10K como pulldown) ---
const int PIN_PULSADOR_ENTRADA = 32;
const int PIN_PULSADOR_SALIDA  = 33;

// --- Pines de los LED de estado (solo en el nivel inicial) ---
// GPIO libres y seguros; en intermedio el display reemplaza a los LED.
const int PIN_LED_VERDE = 27;  // encendido = hay lugares disponibles
const int PIN_LED_ROJO  = 14;  // encendido = estacionamiento completo

// --- Angulos de la barrera ---
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// Espera (ms) a que el auto cruce antes de bajar la barrera.
const unsigned long TIEMPO_PASO_MS = 3000;

// Lugares disponibles. Arranca vacio: 8 lugares libres.
int lugares = CAPACIDAD;

Servo servoEntrada;
Servo servoSalida;

void setup() {
  pinMode(PIN_PULSADOR_ENTRADA, INPUT);
  pinMode(PIN_PULSADOR_SALIDA, INPUT);
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);

  servoEntrada.attach(PIN_SERVO_ENTRADA);
  servoSalida.attach(PIN_SERVO_SALIDA);
  servoEntrada.write(ANGULO_CERRADA);
  servoSalida.write(ANGULO_CERRADA);
}

void loop() {
  // --- ENTRADA: solo se abre si hay al menos un lugar libre ---
  if (digitalRead(PIN_PULSADOR_ENTRADA) == HIGH && lugares >= 1) {
    servoEntrada.write(ANGULO_ABIERTA);
    while (digitalRead(PIN_PULSADOR_ENTRADA) == HIGH) {
    }
    delay(TIEMPO_PASO_MS);
    servoEntrada.write(ANGULO_CERRADA);
    lugares = lugares - 1;
  }

  // --- SALIDA: guard (lugares < CAPACIDAD) evita superar la capacidad ---
  if (digitalRead(PIN_PULSADOR_SALIDA) == HIGH && lugares < CAPACIDAD) {
    servoSalida.write(ANGULO_ABIERTA);
    while (digitalRead(PIN_PULSADOR_SALIDA) == HIGH) {
    }
    delay(TIEMPO_PASO_MS);
    servoSalida.write(ANGULO_CERRADA);
    lugares = lugares + 1;
  }

  // --- LED de estado ---
  if (lugares > 0) {
    digitalWrite(PIN_LED_VERDE, HIGH);
    digitalWrite(PIN_LED_ROJO, LOW);
  } else {
    digitalWrite(PIN_LED_VERDE, LOW);
    digitalWrite(PIN_LED_ROJO, HIGH);
  }
}

// Estacionamiento automatizado — Nivel Intermedio (Arduino UNO).
//
// Igual que el nivel inicial (dos barreras + contador de lugares), pero los dos
// LED verde/rojo se reemplazan por un DISPLAY DE 7 SEGMENTOS que muestra el
// numero EXACTO de lugares libres (0 a 8), como pide la situacion-problema
// (Juana quiere saber cuantos lugares quedan, no solo si hay o no hay).
//
// Display de 7 segmentos de CATODO COMUN: cada segmento (a..g) se enciende con
// un HIGH en su pin. La tabla segmentos[10][7] define que segmentos van
// prendidos para cada digito, y escribir_numero() la aplica.
//
// Plataforma: Arduino UNO. Proyecto de BAJA TENSION (servos 5 V, display,
// pulsadores): no hay 220 V ni agua, no lleva advertencias electricas.
//
// Nivel intermedio: se permite delay() (fiel a la progresion del original).
//
// Basado en: Fragmentos de codigo del Nivel Intermedio (Pasos 3 y 4) —
// Estacionamiento Automatizado, Saberes Digitales (INET/EDUCAR 2019).
// CORRECCION DE BUG CRITICO (ver README): servoEntrada/servoSalida se
// remapean de los pines 0/1 (RX/TX del USB, que rompen la carga y el serial)
// a los pines 4 y 8.

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Capacidad del estacionamiento ---
const int CAPACIDAD = 8;

// --- Pines de las barreras (servos) — REMAPEADOS (bug del original) ---
const int PIN_SERVO_ENTRADA = 4;  // original: pin 0 (RX) = BUG
const int PIN_SERVO_SALIDA  = 8;  // original: pin 1 (TX) = BUG

// --- Pines de los pulsadores (10K como pulldown, del original) ---
const int PIN_PULSADOR_ENTRADA = 2;
const int PIN_PULSADOR_SALIDA  = 3;

// --- Pines del display de 7 segmentos (segmentos a..g), fieles al original ---
const int PIN_A = 12;
const int PIN_B = 13;
const int PIN_C = 5;
const int PIN_D = 6;
const int PIN_E = 7;
const int PIN_F = 11;
const int PIN_G = 10;

// --- Angulos de la barrera ---
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// Espera (ms) a que el auto cruce antes de bajar la barrera.
const unsigned long TIEMPO_PASO_MS = 3000;

// Lugares disponibles. Arranca vacio: 8 lugares libres.
int lugares = CAPACIDAD;

// Vector de 10x7 con la configuracion de los segmentos {a,b,c,d,e,f,g} de cada
// caracter numerico (1 = segmento encendido). Es la tabla del original.
int segmentos[10][7] = { { 1, 1, 1, 1, 1, 1, 0 },   // 0
                         { 0, 1, 1, 0, 0, 0, 0 },   // 1
                         { 1, 1, 0, 1, 1, 0, 1 },   // 2
                         { 1, 1, 1, 1, 0, 0, 1 },   // 3
                         { 0, 1, 1, 0, 0, 1, 1 },   // 4
                         { 1, 0, 1, 1, 0, 1, 1 },   // 5
                         { 1, 0, 1, 1, 1, 1, 1 },   // 6
                         { 1, 1, 1, 0, 0, 0, 0 },   // 7
                         { 1, 1, 1, 1, 1, 1, 1 },   // 8
                         { 1, 1, 1, 1, 0, 1, 1 } }; // 9

Servo servoEntrada;
Servo servoSalida;

// escribir_numero recibe un valor (0 a 9) y enciende/apaga los segmentos
// correspondientes segun la tabla "segmentos".
void escribir_numero(int num) {
  digitalWrite(PIN_A, segmentos[num][0]);
  digitalWrite(PIN_B, segmentos[num][1]);
  digitalWrite(PIN_C, segmentos[num][2]);
  digitalWrite(PIN_D, segmentos[num][3]);
  digitalWrite(PIN_E, segmentos[num][4]);
  digitalWrite(PIN_F, segmentos[num][5]);
  digitalWrite(PIN_G, segmentos[num][6]);
}

void setup() {
  pinMode(PIN_PULSADOR_ENTRADA, INPUT);
  pinMode(PIN_PULSADOR_SALIDA, INPUT);

  pinMode(PIN_A, OUTPUT);
  pinMode(PIN_B, OUTPUT);
  pinMode(PIN_C, OUTPUT);
  pinMode(PIN_D, OUTPUT);
  pinMode(PIN_E, OUTPUT);
  pinMode(PIN_F, OUTPUT);
  pinMode(PIN_G, OUTPUT);

  servoEntrada.attach(PIN_SERVO_ENTRADA);
  servoSalida.attach(PIN_SERVO_SALIDA);
  servoEntrada.write(ANGULO_CERRADA);
  servoSalida.write(ANGULO_CERRADA);

  // Mostramos el valor inicial de lugares (8) en el display.
  escribir_numero(lugares);
}

void loop() {
  // --- ENTRADA: solo se abre si hay al menos un lugar libre ---
  if (digitalRead(PIN_PULSADOR_ENTRADA) == HIGH && lugares >= 1) {
    servoEntrada.write(ANGULO_ABIERTA);
    while (digitalRead(PIN_PULSADOR_ENTRADA) == HIGH) {
    }
    delay(TIEMPO_PASO_MS);
    servoEntrada.write(ANGULO_CERRADA);
    lugares = lugares - 1;
    escribir_numero(lugares);
  }

  // --- SALIDA: guard lugares < CAPACIDAD evita superar 8 (y un indice fuera
  //     de rango en la tabla segmentos[]) ---
  if (digitalRead(PIN_PULSADOR_SALIDA) == HIGH && lugares < CAPACIDAD) {
    servoSalida.write(ANGULO_ABIERTA);
    while (digitalRead(PIN_PULSADOR_SALIDA) == HIGH) {
    }
    delay(TIEMPO_PASO_MS);
    servoSalida.write(ANGULO_CERRADA);
    lugares = lugares + 1;
    escribir_numero(lugares);
  }
}

// Estacionamiento automatizado — Nivel Intermedio (ESP32 DevKit v1).
//
// Igual que el nivel inicial (dos barreras + contador de lugares), pero los dos
// LED verde/rojo se reemplazan por un DISPLAY DE 7 SEGMENTOS que muestra el
// numero EXACTO de lugares libres (0 a 8).
//
// Display de 7 segmentos de CATODO COMUN: cada segmento (a..g) se enciende con
// un HIGH. La tabla segmentos[10][7] define que segmentos van prendidos para
// cada digito y escribir_numero() la aplica.
//
// Plataforma: ESP32 (DevKit v1). Servo con ESP32Servo. Proyecto de BAJA
// TENSION: sin 220 V ni agua. Nota electrica: el ESP32 trabaja a 3,3 V; los
// servos se alimentan desde 5 V con GND comun.
//
// Nivel intermedio: se permite delay() (fiel a la progresion del original).
//
// Basado en: Fragmentos de codigo del Nivel Intermedio (Pasos 3 y 4) —
// Estacionamiento Automatizado, Saberes Digitales (INET/EDUCAR 2019).

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Capacidad del estacionamiento ---
const int CAPACIDAD = 8;

// --- Pines de las barreras (servos) — GPIO del contrato ---
const int PIN_SERVO_ENTRADA = 25;
const int PIN_SERVO_SALIDA  = 26;

// --- Pines de los pulsadores (con resistencia de 10K como pulldown) ---
const int PIN_PULSADOR_ENTRADA = 32;
const int PIN_PULSADOR_SALIDA  = 33;

// --- Pines del display de 7 segmentos (segmentos a..g) — GPIO del contrato ---
const int PIN_A = 16;
const int PIN_B = 17;
const int PIN_C = 18;
const int PIN_D = 19;
const int PIN_E = 21;
const int PIN_F = 22;
const int PIN_G = 23;

// --- Angulos de la barrera ---
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// Espera (ms) a que el auto cruce antes de bajar la barrera.
const unsigned long TIEMPO_PASO_MS = 3000;

// Lugares disponibles. Arranca vacio: 8 lugares libres.
int lugares = CAPACIDAD;

// Vector de 10x7 con la configuracion de los segmentos {a,b,c,d,e,f,g}.
int segmentos[10][7] = { { 1, 1, 1, 1, 1, 1, 0 },   // 0
                         { 0, 1, 1, 0, 0, 0, 0 },   // 1
                         { 1, 1, 0, 1, 1, 0, 1 },   // 2
                         { 1, 1, 1, 1, 0, 0, 1 },   // 3
                         { 0, 1, 1, 0, 0, 1, 1 },   // 4
                         { 1, 0, 1, 1, 0, 1, 1 },   // 5
                         { 1, 0, 1, 1, 1, 1, 1 },   // 6
                         { 1, 1, 1, 0, 0, 0, 0 },   // 7
                         { 1, 1, 1, 1, 1, 1, 1 },   // 8
                         { 1, 1, 1, 1, 0, 1, 1 } }; // 9

Servo servoEntrada;
Servo servoSalida;

void escribir_numero(int num) {
  digitalWrite(PIN_A, segmentos[num][0]);
  digitalWrite(PIN_B, segmentos[num][1]);
  digitalWrite(PIN_C, segmentos[num][2]);
  digitalWrite(PIN_D, segmentos[num][3]);
  digitalWrite(PIN_E, segmentos[num][4]);
  digitalWrite(PIN_F, segmentos[num][5]);
  digitalWrite(PIN_G, segmentos[num][6]);
}

void setup() {
  pinMode(PIN_PULSADOR_ENTRADA, INPUT);
  pinMode(PIN_PULSADOR_SALIDA, INPUT);

  pinMode(PIN_A, OUTPUT);
  pinMode(PIN_B, OUTPUT);
  pinMode(PIN_C, OUTPUT);
  pinMode(PIN_D, OUTPUT);
  pinMode(PIN_E, OUTPUT);
  pinMode(PIN_F, OUTPUT);
  pinMode(PIN_G, OUTPUT);

  servoEntrada.attach(PIN_SERVO_ENTRADA);
  servoSalida.attach(PIN_SERVO_SALIDA);
  servoEntrada.write(ANGULO_CERRADA);
  servoSalida.write(ANGULO_CERRADA);

  escribir_numero(lugares);
}

void loop() {
  // --- ENTRADA: solo se abre si hay al menos un lugar libre ---
  if (digitalRead(PIN_PULSADOR_ENTRADA) == HIGH && lugares >= 1) {
    servoEntrada.write(ANGULO_ABIERTA);
    while (digitalRead(PIN_PULSADOR_ENTRADA) == HIGH) {
    }
    delay(TIEMPO_PASO_MS);
    servoEntrada.write(ANGULO_CERRADA);
    lugares = lugares - 1;
    escribir_numero(lugares);
  }

  // --- SALIDA: guard lugares < CAPACIDAD evita superar 8 (indice fuera de
  //     rango en segmentos[]) ---
  if (digitalRead(PIN_PULSADOR_SALIDA) == HIGH && lugares < CAPACIDAD) {
    servoSalida.write(ANGULO_ABIERTA);
    while (digitalRead(PIN_PULSADOR_SALIDA) == HIGH) {
    }
    delay(TIEMPO_PASO_MS);
    servoSalida.write(ANGULO_CERRADA);
    lugares = lugares + 1;
    escribir_numero(lugares);
  }
}

// Estacionamiento automatizado — Nivel Avanzado, no bloqueante (Arduino UNO).
//
// Misma logica que el intermedio (dos barreras + display de 7 segmentos con los
// lugares libres), pero SIN delay() ni while() de espera: cada barrera se
// maneja con una pequena MAQUINA DE ESTADOS basada en millis(). Asi el programa
// nunca queda "colgado" y puede atender ambas barreras a la vez; es la base
// sobre la que se monta el IoT (estacionamiento-iot.ino, solo ESP32).
//
// Estados de cada barrera:
//   CERRADA  -> si el pulsador esta presionado (y corresponde), abre la barrera.
//   ABIERTA  -> espera a que el auto libere el pulsador; ahi anota el instante.
//   CERRANDO -> pasados 3 s del cruce, baja la barrera y actualiza el contador.
//
// Plataforma: Arduino UNO. Proyecto de BAJA TENSION: no hay 220 V ni agua.
//
// Basado en: Nivel Intermedio (Paso 4) + Nivel Avanzado (Paso 5, "codigo no
// bloqueante con millis()") — Estacionamiento Automatizado, Saberes Digitales
// (INET/EDUCAR 2019).
// CORRECCION DE BUG CRITICO (ver README): servos remapeados de los pines 0/1
// (RX/TX del USB) a los pines 4 y 8.

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Capacidad del estacionamiento ---
const int CAPACIDAD = 8;

// --- Pines de las barreras (servos) — REMAPEADOS (bug del original) ---
const int PIN_SERVO_ENTRADA = 4;  // original: pin 0 (RX) = BUG
const int PIN_SERVO_SALIDA  = 8;  // original: pin 1 (TX) = BUG

// --- Pines de los pulsadores (10K como pulldown, del original) ---
const int PIN_PULSADOR_ENTRADA = 2;
const int PIN_PULSADOR_SALIDA  = 3;

// --- Pines del display de 7 segmentos (segmentos a..g) ---
const int PIN_A = 12;
const int PIN_B = 13;
const int PIN_C = 5;
const int PIN_D = 6;
const int PIN_E = 7;
const int PIN_F = 11;
const int PIN_G = 10;

// --- Angulos de la barrera ---
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// Espera (ms) a que el auto cruce antes de bajar la barrera.
const unsigned long TIEMPO_PASO_MS = 3000;

// Estados de la maquina de cada barrera.
const int CERRADA  = 0;
const int ABIERTA  = 1;
const int CERRANDO = 2;

// Lugares disponibles. Arranca vacio: 8 lugares libres.
int lugares = CAPACIDAD;

// Estado y cronometro de cada barrera.
int estadoEntrada = CERRADA;
int estadoSalida  = CERRADA;
unsigned long tLiberadoEntrada = 0;
unsigned long tLiberadoSalida  = 0;

int segmentos[10][7] = { { 1, 1, 1, 1, 1, 1, 0 },   // 0
                         { 0, 1, 1, 0, 0, 0, 0 },   // 1
                         { 1, 1, 0, 1, 1, 0, 1 },   // 2
                         { 1, 1, 1, 1, 0, 0, 1 },   // 3
                         { 0, 1, 1, 0, 0, 1, 1 },   // 4
                         { 1, 0, 1, 1, 0, 1, 1 },   // 5
                         { 1, 0, 1, 1, 1, 1, 1 },   // 6
                         { 1, 1, 1, 0, 0, 0, 0 },   // 7
                         { 1, 1, 1, 1, 1, 1, 1 },   // 8
                         { 1, 1, 1, 1, 0, 1, 1 } }; // 9

Servo servoEntrada;
Servo servoSalida;

void escribir_numero(int num) {
  digitalWrite(PIN_A, segmentos[num][0]);
  digitalWrite(PIN_B, segmentos[num][1]);
  digitalWrite(PIN_C, segmentos[num][2]);
  digitalWrite(PIN_D, segmentos[num][3]);
  digitalWrite(PIN_E, segmentos[num][4]);
  digitalWrite(PIN_F, segmentos[num][5]);
  digitalWrite(PIN_G, segmentos[num][6]);
}

// Maquina de estados de UNA barrera (no bloqueante). esEntrada decide si el
// paso de un auto RESTA (entrada) o SUMA (salida) un lugar, y si la barrera
// puede abrirse (entrada: solo si quedan lugares; salida: solo si hay algun
// auto adentro).
void gestionarBarrera(Servo &servo, int pinPulsador, int &estado,
                      unsigned long &tLiberado, bool esEntrada) {
  switch (estado) {
    case CERRADA: {
      bool puedeAbrir = esEntrada ? (lugares >= 1) : (lugares < CAPACIDAD);
      if (digitalRead(pinPulsador) == HIGH && puedeAbrir) {
        servo.write(ANGULO_ABIERTA);
        estado = ABIERTA;
      }
      break;
    }
    case ABIERTA: {
      // Esperamos a que el auto libere el pulsador (sin bloquear).
      if (digitalRead(pinPulsador) == LOW) {
        tLiberado = millis();
        estado = CERRANDO;
      }
      break;
    }
    case CERRANDO: {
      // Pasados 3 s del cruce, bajamos la barrera y actualizamos el contador.
      if (millis() - tLiberado >= TIEMPO_PASO_MS) {
        servo.write(ANGULO_CERRADA);
        if (esEntrada) {
          lugares = lugares - 1;
        } else {
          lugares = lugares + 1;
        }
        escribir_numero(lugares);
        estado = CERRADA;
      }
      break;
    }
  }
}

void setup() {
  pinMode(PIN_PULSADOR_ENTRADA, INPUT);
  pinMode(PIN_PULSADOR_SALIDA, INPUT);

  pinMode(PIN_A, OUTPUT);
  pinMode(PIN_B, OUTPUT);
  pinMode(PIN_C, OUTPUT);
  pinMode(PIN_D, OUTPUT);
  pinMode(PIN_E, OUTPUT);
  pinMode(PIN_F, OUTPUT);
  pinMode(PIN_G, OUTPUT);

  servoEntrada.attach(PIN_SERVO_ENTRADA);
  servoSalida.attach(PIN_SERVO_SALIDA);
  servoEntrada.write(ANGULO_CERRADA);
  servoSalida.write(ANGULO_CERRADA);

  escribir_numero(lugares);
}

void loop() {
  // Ambas barreras se atienden en cada vuelta, sin que ninguna bloquee.
  gestionarBarrera(servoEntrada, PIN_PULSADOR_ENTRADA, estadoEntrada,
                   tLiberadoEntrada, true);
  gestionarBarrera(servoSalida, PIN_PULSADOR_SALIDA, estadoSalida,
                   tLiberadoSalida, false);
}

// Estacionamiento automatizado — Nivel Avanzado, no bloqueante (ESP32 DevKit v1).
//
// Misma logica que el intermedio (dos barreras + display de 7 segmentos con los
// lugares libres), pero SIN delay() ni while() de espera: cada barrera se
// maneja con una MAQUINA DE ESTADOS basada en millis(). El programa nunca queda
// "colgado" y puede atender ambas barreras a la vez; es la base sobre la que se
// monta el IoT (estacionamiento-iot.ino).
//
// Estados de cada barrera:
//   CERRADA  -> si el pulsador esta presionado (y corresponde), abre la barrera.
//   ABIERTA  -> espera a que el auto libere el pulsador; ahi anota el instante.
//   CERRANDO -> pasados 3 s del cruce, baja la barrera y actualiza el contador.
//
// Plataforma: ESP32 (DevKit v1). Servo con ESP32Servo. Proyecto de BAJA
// TENSION: sin 220 V ni agua. Nota electrica: 3,3 V; servos desde 5 V, GND comun.
//
// Basado en: Nivel Intermedio (Paso 4) + Nivel Avanzado (Paso 5, "codigo no
// bloqueante con millis()") — Estacionamiento Automatizado, Saberes Digitales
// (INET/EDUCAR 2019).

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Capacidad del estacionamiento ---
const int CAPACIDAD = 8;

// --- Pines de las barreras (servos) — GPIO del contrato ---
const int PIN_SERVO_ENTRADA = 25;
const int PIN_SERVO_SALIDA  = 26;

// --- Pines de los pulsadores (con resistencia de 10K como pulldown) ---
const int PIN_PULSADOR_ENTRADA = 32;
const int PIN_PULSADOR_SALIDA  = 33;

// --- Pines del display de 7 segmentos (segmentos a..g) — GPIO del contrato ---
const int PIN_A = 16;
const int PIN_B = 17;
const int PIN_C = 18;
const int PIN_D = 19;
const int PIN_E = 21;
const int PIN_F = 22;
const int PIN_G = 23;

// --- Angulos de la barrera ---
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// Espera (ms) a que el auto cruce antes de bajar la barrera.
const unsigned long TIEMPO_PASO_MS = 3000;

// Estados de la maquina de cada barrera.
const int CERRADA  = 0;
const int ABIERTA  = 1;
const int CERRANDO = 2;

// Lugares disponibles. Arranca vacio: 8 lugares libres.
int lugares = CAPACIDAD;

// Estado y cronometro de cada barrera.
int estadoEntrada = CERRADA;
int estadoSalida  = CERRADA;
unsigned long tLiberadoEntrada = 0;
unsigned long tLiberadoSalida  = 0;

int segmentos[10][7] = { { 1, 1, 1, 1, 1, 1, 0 },   // 0
                         { 0, 1, 1, 0, 0, 0, 0 },   // 1
                         { 1, 1, 0, 1, 1, 0, 1 },   // 2
                         { 1, 1, 1, 1, 0, 0, 1 },   // 3
                         { 0, 1, 1, 0, 0, 1, 1 },   // 4
                         { 1, 0, 1, 1, 0, 1, 1 },   // 5
                         { 1, 0, 1, 1, 1, 1, 1 },   // 6
                         { 1, 1, 1, 0, 0, 0, 0 },   // 7
                         { 1, 1, 1, 1, 1, 1, 1 },   // 8
                         { 1, 1, 1, 1, 0, 1, 1 } }; // 9

Servo servoEntrada;
Servo servoSalida;

void escribir_numero(int num) {
  digitalWrite(PIN_A, segmentos[num][0]);
  digitalWrite(PIN_B, segmentos[num][1]);
  digitalWrite(PIN_C, segmentos[num][2]);
  digitalWrite(PIN_D, segmentos[num][3]);
  digitalWrite(PIN_E, segmentos[num][4]);
  digitalWrite(PIN_F, segmentos[num][5]);
  digitalWrite(PIN_G, segmentos[num][6]);
}

// Maquina de estados de UNA barrera (no bloqueante). esEntrada decide si el
// paso de un auto RESTA (entrada) o SUMA (salida) un lugar, y si la barrera
// puede abrirse (entrada: solo si quedan lugares; salida: solo si hay algun
// auto adentro).
void gestionarBarrera(Servo &servo, int pinPulsador, int &estado,
                      unsigned long &tLiberado, bool esEntrada) {
  switch (estado) {
    case CERRADA: {
      bool puedeAbrir = esEntrada ? (lugares >= 1) : (lugares < CAPACIDAD);
      if (digitalRead(pinPulsador) == HIGH && puedeAbrir) {
        servo.write(ANGULO_ABIERTA);
        estado = ABIERTA;
      }
      break;
    }
    case ABIERTA: {
      if (digitalRead(pinPulsador) == LOW) {
        tLiberado = millis();
        estado = CERRANDO;
      }
      break;
    }
    case CERRANDO: {
      if (millis() - tLiberado >= TIEMPO_PASO_MS) {
        servo.write(ANGULO_CERRADA);
        if (esEntrada) {
          lugares = lugares - 1;
        } else {
          lugares = lugares + 1;
        }
        escribir_numero(lugares);
        estado = CERRADA;
      }
      break;
    }
  }
}

void setup() {
  pinMode(PIN_PULSADOR_ENTRADA, INPUT);
  pinMode(PIN_PULSADOR_SALIDA, INPUT);

  pinMode(PIN_A, OUTPUT);
  pinMode(PIN_B, OUTPUT);
  pinMode(PIN_C, OUTPUT);
  pinMode(PIN_D, OUTPUT);
  pinMode(PIN_E, OUTPUT);
  pinMode(PIN_F, OUTPUT);
  pinMode(PIN_G, OUTPUT);

  servoEntrada.attach(PIN_SERVO_ENTRADA);
  servoSalida.attach(PIN_SERVO_SALIDA);
  servoEntrada.write(ANGULO_CERRADA);
  servoSalida.write(ANGULO_CERRADA);

  escribir_numero(lugares);
}

void loop() {
  gestionarBarrera(servoEntrada, PIN_PULSADOR_ENTRADA, estadoEntrada,
                   tLiberadoEntrada, true);
  gestionarBarrera(servoSalida, PIN_PULSADOR_SALIDA, estadoSalida,
                   tLiberadoSalida, false);
}

// Estacionamiento automatizado — Nivel Avanzado + IoT (ESP32 DevKit v1).
//
// Toma el estacionamiento no bloqueante (estacionamiento-no-bloqueante.ino) y
// le suma monitoreo remoto: cada vez que ENTRA o SALE un auto (es decir, cada
// vez que cambia "lugares"), publica en Adafruit IO la cantidad de plazas
// OCUPADAS ( = 8 - lugares ), tal como hace el original. Asi los primos de
// Juana pueden ver desde el celular cuan lleno esta el estacionamiento.
//
// Feed: "estacionamiento1" (cambiar IO_FEED a "estacionamiento2" para la
// segunda maqueta, como indica la guia: si no, ambas publicarian al mismo feed
// y en el panel se mezclaria la informacion).
//
// La publicacion es EVENT-DRIVEN: solo se publica en el instante del cambio
// (no en cada vuelta de loop()), de modo que el sistema NO supera el cupo
// gratuito de Adafruit IO (30 publicaciones/minuto) — el original publicaba
// dentro del ciclo y podia excederlo.
//
// Plataforma: ESP32 (DevKit v1) — WiFi integrado. Servo con ESP32Servo.
// Proyecto de BAJA TENSION: sin 220 V ni agua. Nota electrica: 3,3 V; servos
// desde 5 V con GND comun.
//
// Basado en: Fragmento de codigo del Nivel Avanzado (Paso 6, publicacion de las
// plazas ocupadas) — Estacionamiento Automatizado, Saberes Digitales
// (INET/EDUCAR 2019).
// Modernizaciones / desvios (ver README):
//  (1) OBLOQ + ObloqAdafruit sobre SoftwareSerial(8,9) estan discontinuados y,
//      ademas, en el original conviven con los servos en pines 0/1 (RX/TX) que
//      rompen el USB. Se reemplazan por el WiFi NATIVO del ESP32 + MQTT contra
//      io.adafruit.com (libreria "Adafruit MQTT Library"). El IoT solo se
//      implementa en ESP32; en UNO es conceptual.
//  (2) Publicacion EVENT-DRIVEN (solo al cambiar "lugares"), no en cada vuelta.
//  (3) Reconexion MQTT NO bloqueante (reintento cada 5 s), sin frenar barreras.

#include <WiFi.h>
#include <ESP32Servo.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"

// ---------------------------------------------------------------------------
// Credenciales: reemplazar por las propias. El usuario y la key de Adafruit se
// copian desde io.adafruit.com con el icono de la "llave" (como en la guia).
// ---------------------------------------------------------------------------
#define WIFI_SSID     "TU_SSID"
#define WIFI_PASSWORD "TU_PASSWORD"
#define IO_USERNAME   "TU_USUARIO_ADAFRUIT"
#define IO_KEY        "TU_KEY_ADAFRUIT"

// Feed al que publicamos. Cambiar a "estacionamiento2" para la segunda maqueta.
#define IO_FEED       "estacionamiento1"

// Servidor MQTT de Adafruit IO.
const char SERVIDOR_MQTT[] = "io.adafruit.com";
const int  PUERTO_MQTT     = 1883;

// --- Capacidad del estacionamiento ---
const int CAPACIDAD = 8;

// --- Pines de las barreras (servos) — GPIO del contrato ---
const int PIN_SERVO_ENTRADA = 25;
const int PIN_SERVO_SALIDA  = 26;

// --- Pines de los pulsadores (con resistencia de 10K como pulldown) ---
const int PIN_PULSADOR_ENTRADA = 32;
const int PIN_PULSADOR_SALIDA  = 33;

// --- Pines del display de 7 segmentos (segmentos a..g) — GPIO del contrato ---
const int PIN_A = 16;
const int PIN_B = 17;
const int PIN_C = 18;
const int PIN_D = 19;
const int PIN_E = 21;
const int PIN_F = 22;
const int PIN_G = 23;

// --- Angulos de la barrera ---
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// Espera (ms) a que el auto cruce antes de bajar la barrera.
const unsigned long TIEMPO_PASO_MS = 3000;

// Estados de la maquina de cada barrera.
const int CERRADA  = 0;
const int ABIERTA  = 1;
const int CERRANDO = 2;

// Lugares disponibles. Arranca vacio: 8 lugares libres.
int lugares = CAPACIDAD;

// Estado y cronometro de cada barrera.
int estadoEntrada = CERRADA;
int estadoSalida  = CERRADA;
unsigned long tLiberadoEntrada = 0;
unsigned long tLiberadoSalida  = 0;

int segmentos[10][7] = { { 1, 1, 1, 1, 1, 1, 0 },   // 0
                         { 0, 1, 1, 0, 0, 0, 0 },   // 1
                         { 1, 1, 0, 1, 1, 0, 1 },   // 2
                         { 1, 1, 1, 1, 0, 0, 1 },   // 3
                         { 0, 1, 1, 0, 0, 1, 1 },   // 4
                         { 1, 0, 1, 1, 0, 1, 1 },   // 5
                         { 1, 0, 1, 1, 1, 1, 1 },   // 6
                         { 1, 1, 1, 0, 0, 0, 0 },   // 7
                         { 1, 1, 1, 1, 1, 1, 1 },   // 8
                         { 1, 1, 1, 1, 0, 1, 1 } }; // 9

// --- WiFi + MQTT (Adafruit IO) ---
WiFiClient clienteWifi;
Adafruit_MQTT_Client mqtt(&clienteWifi, SERVIDOR_MQTT, PUERTO_MQTT,
                          IO_USERNAME, IO_KEY);
Adafruit_MQTT_Publish feedEstacionamiento(&mqtt,
                                          IO_USERNAME "/feeds/" IO_FEED);

// Reintento de conexion MQTT sin bloquear.
const unsigned long INTERVALO_REINTENTO_MQTT_MS = 5000;
unsigned long millisUltimoIntentoMqtt = 0;

// Ultima cantidad de OCUPADAS publicada con exito (-1 fuerza la 1ra publicacion).
int ocupadasPublicada = -1;

Servo servoEntrada;
Servo servoSalida;

void escribir_numero(int num) {
  digitalWrite(PIN_A, segmentos[num][0]);
  digitalWrite(PIN_B, segmentos[num][1]);
  digitalWrite(PIN_C, segmentos[num][2]);
  digitalWrite(PIN_D, segmentos[num][3]);
  digitalWrite(PIN_E, segmentos[num][4]);
  digitalWrite(PIN_F, segmentos[num][5]);
  digitalWrite(PIN_G, segmentos[num][6]);
}

// Maquina de estados de UNA barrera (no bloqueante). esEntrada decide si el
// paso de un auto RESTA (entrada) o SUMA (salida) un lugar, y si la barrera
// puede abrirse.
void gestionarBarrera(Servo &servo, int pinPulsador, int &estado,
                      unsigned long &tLiberado, bool esEntrada) {
  switch (estado) {
    case CERRADA: {
      bool puedeAbrir = esEntrada ? (lugares >= 1) : (lugares < CAPACIDAD);
      if (digitalRead(pinPulsador) == HIGH && puedeAbrir) {
        servo.write(ANGULO_ABIERTA);
        estado = ABIERTA;
      }
      break;
    }
    case ABIERTA: {
      if (digitalRead(pinPulsador) == LOW) {
        tLiberado = millis();
        estado = CERRANDO;
      }
      break;
    }
    case CERRANDO: {
      if (millis() - tLiberado >= TIEMPO_PASO_MS) {
        servo.write(ANGULO_CERRADA);
        if (esEntrada) {
          lugares = lugares - 1;
        } else {
          lugares = lugares + 1;
        }
        escribir_numero(lugares);
        estado = CERRADA;
      }
      break;
    }
  }
}

// Mantiene viva la conexion MQTT sin bloquear: si esta caida, reintenta como
// mucho una vez cada 5 s.
void mantenerConexionMqtt() {
  if (mqtt.connected()) {
    return;
  }
  unsigned long millisActual = millis();
  if (millisActual - millisUltimoIntentoMqtt < INTERVALO_REINTENTO_MQTT_MS) {
    return;
  }
  millisUltimoIntentoMqtt = millisActual;

  Serial.print("Conectando a Adafruit IO... ");
  int8_t resultado = mqtt.connect();  // 0 = conexion exitosa
  if (resultado == 0) {
    Serial.println("conectado.");
  } else {
    Serial.println(mqtt.connectErrorString(resultado));
    mqtt.disconnect();
  }
}

// Publica la cantidad de plazas OCUPADAS (8 - lugares) SOLO cuando cambia
// (event-driven). Si no hay conexion o el publish falla, no se actualiza el
// registro: se reintenta cuando vuelva la conexion o en el proximo cambio.
void publicarOcupadasSiCambio() {
  int ocupadas = CAPACIDAD - lugares;
  if (ocupadas == ocupadasPublicada) {
    return;  // sin cambios: nada que publicar
  }
  if (!mqtt.connected()) {
    return;  // sin internet: se publicara cuando reconecte
  }
  if (feedEstacionamiento.publish((int32_t) ocupadas)) {
    ocupadasPublicada = ocupadas;
  }
}

void setup() {
  Serial.begin(115200);

  pinMode(PIN_PULSADOR_ENTRADA, INPUT);
  pinMode(PIN_PULSADOR_SALIDA, INPUT);

  pinMode(PIN_A, OUTPUT);
  pinMode(PIN_B, OUTPUT);
  pinMode(PIN_C, OUTPUT);
  pinMode(PIN_D, OUTPUT);
  pinMode(PIN_E, OUTPUT);
  pinMode(PIN_F, OUTPUT);
  pinMode(PIN_G, OUTPUT);

  servoEntrada.attach(PIN_SERVO_ENTRADA);
  servoSalida.attach(PIN_SERVO_SALIDA);
  servoEntrada.write(ANGULO_CERRADA);
  servoSalida.write(ANGULO_CERRADA);

  escribir_numero(lugares);

  // Conexion WiFi. Bloquear aca con delay() es aceptable: el ciclo de barreras
  // todavia no arranco. Una vez en loop(), nada bloquea.
  Serial.print("Conectando a la red WiFi");
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("WiFi conectado, IP: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  // 1) Barreras no bloqueantes: al cerrar, cambian "lugares".
  gestionarBarrera(servoEntrada, PIN_PULSADOR_ENTRADA, estadoEntrada,
                   tLiberadoEntrada, true);
  gestionarBarrera(servoSalida, PIN_PULSADOR_SALIDA, estadoSalida,
                   tLiberadoSalida, false);

  // 2) Mantenimiento IoT + publicacion event-driven. publicarOcupadasSiCambio()
  //    solo envia datos cuando "lugares" cambio, asi respeta el cupo de Adafruit.
  mantenerConexionMqtt();
  publicarOcupadasSiCambio();
}