Sistema de Semaforización

// Parpadeo de un LED: el "Hola Mundo" de la electrónica.
// Enciende y apaga un LED cada 1 segundo.
//
// Plataforma: Arduino UNO. El pin 13 tiene un LED integrado en la placa,
// así que este programa funciona incluso antes de conectar el LED externo.
//
// Basado en: Fragmento de código 1 — Sistema de Semaforización,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: se reemplazó el código generado por mBlock3 (_delay, _loop)
// por C++ idiomático de Arduino, con constantes nombradas para pin y tiempos.

// Constantes con nombre en lugar de "números mágicos": si mañana movemos
// el LED a otro pin o queremos otro ritmo, tocamos UNA línea acá arriba
// y no hace falta revisar el resto del programa. Este hábito es la base
// de todos los programas que siguen en la guía.
const int PIN_LED = 13; // LED integrado del UNO

const unsigned long DURACION_ENCENDIDO_MS = 1000;
const unsigned long DURACION_APAGADO_MS   = 1000;

void setup() {
  // Un pin digital puede leer o escribir. Acá declaramos que este pin
  // va a ESCRIBIR (encender y apagar el LED).
  pinMode(PIN_LED, OUTPUT);
}

void loop() {
  // delay() detiene TODO el programa durante ese tiempo. Para un primer
  // programa es ideal: el código se lee de arriba hacia abajo igual que
  // la secuencia real de la luz. En el nivel avanzado veremos por qué
  // esto se vuelve un problema (código "bloqueante") y cómo resolverlo
  // con millis().
  digitalWrite(PIN_LED, HIGH); // encender
  delay(DURACION_ENCENDIDO_MS);
  digitalWrite(PIN_LED, LOW);  // apagar
  delay(DURACION_APAGADO_MS);
}

// Parpadeo de un LED: el "Hola Mundo" de la electrónica.
// Enciende y apaga un LED cada 1 segundo.
//
// Plataforma: ESP32 (DevKit v1). El GPIO 2 tiene un LED azul integrado
// en la placa, así que este programa funciona incluso antes de conectar
// el LED externo.
// Nota eléctrica: el ESP32 trabaja a 3,3 V (no 5 V como el UNO). Con la
// misma resistencia de 220 ohm el LED enciende un poco más tenue, y NUNCA
// hay que inyectar 5 V en un GPIO del ESP32: se puede dañar la placa.
//
// Basado en: Fragmento de código 1 — Sistema de Semaforización,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: se reemplazó el código generado por mBlock3 (_delay, _loop)
// por C++ idiomático de Arduino con constantes nombradas, y se portó la
// guía (pensada para Arduino UNO) a ESP32.

// Constantes con nombre en lugar de "números mágicos": si mañana movemos
// el LED a otro pin o queremos otro ritmo, tocamos UNA línea acá arriba
// y no hace falta revisar el resto del programa. Este hábito es la base
// de todos los programas que siguen en la guía.
const int PIN_LED = 2; // LED integrado del DevKit v1

const unsigned long DURACION_ENCENDIDO_MS = 1000;
const unsigned long DURACION_APAGADO_MS   = 1000;

void setup() {
  // Un pin digital puede leer o escribir. Acá declaramos que este pin
  // va a ESCRIBIR (encender y apagar el LED).
  pinMode(PIN_LED, OUTPUT);
}

void loop() {
  // delay() detiene TODO el programa durante ese tiempo. Para un primer
  // programa es ideal: el código se lee de arriba hacia abajo igual que
  // la secuencia real de la luz. En el nivel avanzado veremos por qué
  // esto se vuelve un problema (código "bloqueante") y cómo resolverlo
  // con millis().
  digitalWrite(PIN_LED, HIGH); // encender
  delay(DURACION_ENCENDIDO_MS);
  digitalWrite(PIN_LED, LOW);  // apagar
  delay(DURACION_APAGADO_MS);
}

// Semáforo simple de tres luces (un solo semáforo).
// Secuencia: verde 5 s → amarillo 1 s → rojo 5 s → rojo+amarillo 1 s,
// y vuelve a empezar. La fase rojo+amarillo avisa que está por venir
// el verde, como en los semáforos reales de varios países.
//
// Plataforma: Arduino UNO.
// Conexión: LED verde → pin 11, LED amarillo → pin 12, LED rojo → pin 13,
// cada uno con su resistencia de 220 ohm a GND.
//
// Basado en: Fragmento de código 2 — Sistema de Semaforización,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: se reemplazó el código generado por mBlock3 (_delay, _loop)
// por C++ idiomático de Arduino, con constantes nombradas para pines y tiempos.

// Pines del semáforo 1 (los mismos del esquema original de la guía).
const int PIN_SEM1_VERDE    = 11;
const int PIN_SEM1_AMARILLO = 12;
const int PIN_SEM1_ROJO     = 13;

// Tiempos de cada fase. Son los MISMOS en toda la guía (y en el simulador):
// si acá se cambian, el comportamiento deja de coincidir con el resto.
const unsigned long DURACION_VERDE_MS         = 5000;
const unsigned long DURACION_AMARILLO_MS      = 1000;
const unsigned long DURACION_ROJO_MS          = 5000;
const unsigned long DURACION_ROJO_AMARILLO_MS = 1000;

void setup() {
  pinMode(PIN_SEM1_VERDE, OUTPUT);
  pinMode(PIN_SEM1_AMARILLO, OUTPUT);
  pinMode(PIN_SEM1_ROJO, OUTPUT);
}

void loop() {
  // En cada fase escribimos las TRES luces, aunque alguna no cambie:
  // así cada bloque describe el estado completo del semáforo y no hay
  // que "acordarse" de qué quedó encendido en la fase anterior.

  // Fase 1: VERDE — los autos circulan.
  digitalWrite(PIN_SEM1_VERDE, HIGH);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, LOW);
  delay(DURACION_VERDE_MS);

  // Fase 2: AMARILLO — atención, prepararse para frenar.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, HIGH);
  digitalWrite(PIN_SEM1_ROJO, LOW);
  delay(DURACION_AMARILLO_MS);

  // Fase 3: ROJO — detenerse.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  delay(DURACION_ROJO_MS);

  // Fase 4: ROJO + AMARILLO — aviso de que está por venir el verde.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, HIGH);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  delay(DURACION_ROJO_AMARILLO_MS);

  // Al terminar la fase 4, loop() vuelve a ejecutarse desde arriba:
  // ese "volver a empezar" automático es lo que hace el ciclo infinito.
}

// Semáforo simple de tres luces (un solo semáforo).
// Secuencia: verde 5 s → amarillo 1 s → rojo 5 s → rojo+amarillo 1 s,
// y vuelve a empezar. La fase rojo+amarillo avisa que está por venir
// el verde, como en los semáforos reales de varios países.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: LED verde → GPIO 16, LED amarillo → GPIO 17, LED rojo → GPIO 18,
// cada uno con su resistencia de 220 ohm a GND.
// Nota eléctrica: el ESP32 trabaja a 3,3 V (no 5 V como el UNO). Con la
// misma resistencia de 220 ohm los LED encienden un poco más tenues, y
// NUNCA hay que inyectar 5 V en un GPIO del ESP32.
//
// Basado en: Fragmento de código 2 — Sistema de Semaforización,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: se reemplazó el código generado por mBlock3 (_delay, _loop)
// por C++ idiomático de Arduino con constantes nombradas, y se portó a ESP32
// usando GPIO seguros (16/17/18, lejos de los pines de arranque o "strapping").

// Pines del semáforo 1.
const int PIN_SEM1_VERDE    = 16;
const int PIN_SEM1_AMARILLO = 17;
const int PIN_SEM1_ROJO     = 18;

// Tiempos de cada fase. Son los MISMOS en toda la guía (y en el simulador):
// si acá se cambian, el comportamiento deja de coincidir con el resto.
const unsigned long DURACION_VERDE_MS         = 5000;
const unsigned long DURACION_AMARILLO_MS      = 1000;
const unsigned long DURACION_ROJO_MS          = 5000;
const unsigned long DURACION_ROJO_AMARILLO_MS = 1000;

void setup() {
  pinMode(PIN_SEM1_VERDE, OUTPUT);
  pinMode(PIN_SEM1_AMARILLO, OUTPUT);
  pinMode(PIN_SEM1_ROJO, OUTPUT);
}

void loop() {
  // En cada fase escribimos las TRES luces, aunque alguna no cambie:
  // así cada bloque describe el estado completo del semáforo y no hay
  // que "acordarse" de qué quedó encendido en la fase anterior.

  // Fase 1: VERDE — los autos circulan.
  digitalWrite(PIN_SEM1_VERDE, HIGH);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, LOW);
  delay(DURACION_VERDE_MS);

  // Fase 2: AMARILLO — atención, prepararse para frenar.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, HIGH);
  digitalWrite(PIN_SEM1_ROJO, LOW);
  delay(DURACION_AMARILLO_MS);

  // Fase 3: ROJO — detenerse.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  delay(DURACION_ROJO_MS);

  // Fase 4: ROJO + AMARILLO — aviso de que está por venir el verde.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, HIGH);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  delay(DURACION_ROJO_AMARILLO_MS);

  // Al terminar la fase 4, loop() vuelve a ejecutarse desde arriba:
  // ese "volver a empezar" automático es lo que hace el ciclo infinito.
}

// Intersección con dos semáforos sincronizados (6 LED).
// Recorre los 8 cuadros del "cómic" de la Fig. 10 de la guía original:
//
//   Cuadro | Semáforo 1      | Semáforo 2      | Duración
//   -------+-----------------+-----------------+---------
//     1    | VERDE           | ROJO            |   5 s
//     2    | AMARILLO        | ROJO            |   1 s
//     3    | ROJO            | ROJO            |   1 s   (todo rojo)
//     4    | ROJO            | ROJO + AMARILLO |   1 s
//     5    | ROJO            | VERDE           |   5 s
//     6    | ROJO            | AMARILLO        |   1 s
//     7    | ROJO            | ROJO            |   1 s   (todo rojo)
//     8    | ROJO + AMARILLO | ROJO            |   1 s
//
// El cuadro 9 es igual al 1: ahí la secuencia vuelve a empezar.
// Los cuadros 3 y 7 dejan TODO en rojo un instante: es el margen de
// seguridad para que la intersección se vacíe antes de habilitar la
// otra calle. Ningún semáforo real pasa de verde a verde sin ese margen.
//
// Plataforma: Arduino UNO.
// Conexión: semáforo 1 → verde 11, amarillo 12, rojo 13;
//           semáforo 2 → verde 8, amarillo 9, rojo 10 (como en la guía).
//
// Basado en: Fragmento de código 3 — Sistema de Semaforización,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: se reemplazó el código generado por mBlock3 (_delay, _loop)
// por C++ idiomático de Arduino con constantes nombradas. Además, cada
// cuadro escribe las SEIS luces completas (el original solo escribía los
// pines que cambiaban): así cada bloque de código se corresponde 1 a 1
// con un cuadro del cómic y puede leerse de forma aislada.

// Semáforo 1 (calle principal).
const int PIN_SEM1_VERDE    = 11;
const int PIN_SEM1_AMARILLO = 12;
const int PIN_SEM1_ROJO     = 13;

// Semáforo 2 (calle transversal).
const int PIN_SEM2_VERDE    = 8;
const int PIN_SEM2_AMARILLO = 9;
const int PIN_SEM2_ROJO     = 10;

// Tiempos de la secuencia (los mismos de toda la guía y del simulador).
const unsigned long DURACION_VERDE_MS         = 5000;
const unsigned long DURACION_AMARILLO_MS      = 1000;
const unsigned long DURACION_TODO_ROJO_MS     = 1000; // margen de seguridad
const unsigned long DURACION_ROJO_AMARILLO_MS = 1000;

void setup() {
  pinMode(PIN_SEM1_VERDE, OUTPUT);
  pinMode(PIN_SEM1_AMARILLO, OUTPUT);
  pinMode(PIN_SEM1_ROJO, OUTPUT);
  pinMode(PIN_SEM2_VERDE, OUTPUT);
  pinMode(PIN_SEM2_AMARILLO, OUTPUT);
  pinMode(PIN_SEM2_ROJO, OUTPUT);
}

void loop() {
  // Cuadro 1: Semáforo 1 VERDE / Semáforo 2 ROJO.
  digitalWrite(PIN_SEM1_VERDE, HIGH);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, LOW);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_VERDE_MS);

  // Cuadro 2: Semáforo 1 AMARILLO / Semáforo 2 ROJO.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, HIGH);
  digitalWrite(PIN_SEM1_ROJO, LOW);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_AMARILLO_MS);

  // Cuadro 3: TODO ROJO — la intersección se vacía antes del cambio.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_TODO_ROJO_MS);

  // Cuadro 4: Semáforo 1 ROJO / Semáforo 2 ROJO + AMARILLO (por arrancar).
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, HIGH);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_ROJO_AMARILLO_MS);

  // Cuadro 5: Semáforo 1 ROJO / Semáforo 2 VERDE — ahora circula la otra calle.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, HIGH);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, LOW);
  delay(DURACION_VERDE_MS);

  // Cuadro 6: Semáforo 1 ROJO / Semáforo 2 AMARILLO.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, HIGH);
  digitalWrite(PIN_SEM2_ROJO, LOW);
  delay(DURACION_AMARILLO_MS);

  // Cuadro 7: TODO ROJO — otra vez el margen de seguridad.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_TODO_ROJO_MS);

  // Cuadro 8: Semáforo 1 ROJO + AMARILLO / Semáforo 2 ROJO.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, HIGH);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_ROJO_AMARILLO_MS);

  // loop() vuelve a empezar: el cuadro 9 del cómic es igual al cuadro 1.
}

// Intersección con dos semáforos sincronizados (6 LED).
// Recorre los 8 cuadros del "cómic" de la Fig. 10 de la guía original:
//
//   Cuadro | Semáforo 1      | Semáforo 2      | Duración
//   -------+-----------------+-----------------+---------
//     1    | VERDE           | ROJO            |   5 s
//     2    | AMARILLO        | ROJO            |   1 s
//     3    | ROJO            | ROJO            |   1 s   (todo rojo)
//     4    | ROJO            | ROJO + AMARILLO |   1 s
//     5    | ROJO            | VERDE           |   5 s
//     6    | ROJO            | AMARILLO        |   1 s
//     7    | ROJO            | ROJO            |   1 s   (todo rojo)
//     8    | ROJO + AMARILLO | ROJO            |   1 s
//
// El cuadro 9 es igual al 1: ahí la secuencia vuelve a empezar.
// Los cuadros 3 y 7 dejan TODO en rojo un instante: es el margen de
// seguridad para que la intersección se vacíe antes de habilitar la
// otra calle. Ningún semáforo real pasa de verde a verde sin ese margen.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: semáforo 1 → verde GPIO 16, amarillo GPIO 17, rojo GPIO 18;
//           semáforo 2 → verde GPIO 19, amarillo GPIO 21, rojo GPIO 22.
// Nota eléctrica: el ESP32 trabaja a 3,3 V (no 5 V como el UNO); nunca
// inyectar 5 V en un GPIO.
//
// Basado en: Fragmento de código 3 — Sistema de Semaforización,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: se reemplazó el código generado por mBlock3 (_delay, _loop)
// por C++ idiomático de Arduino con constantes nombradas y se portó a ESP32
// con GPIO seguros (se evitan los pines de arranque o "strapping"). Además,
// cada cuadro escribe las SEIS luces completas (el original solo escribía
// los pines que cambiaban): así cada bloque de código se corresponde 1 a 1
// con un cuadro del cómic y puede leerse de forma aislada.

// Semáforo 1 (calle principal).
const int PIN_SEM1_VERDE    = 16;
const int PIN_SEM1_AMARILLO = 17;
const int PIN_SEM1_ROJO     = 18;

// Semáforo 2 (calle transversal).
const int PIN_SEM2_VERDE    = 19;
const int PIN_SEM2_AMARILLO = 21;
const int PIN_SEM2_ROJO     = 22;

// Tiempos de la secuencia (los mismos de toda la guía y del simulador).
const unsigned long DURACION_VERDE_MS         = 5000;
const unsigned long DURACION_AMARILLO_MS      = 1000;
const unsigned long DURACION_TODO_ROJO_MS     = 1000; // margen de seguridad
const unsigned long DURACION_ROJO_AMARILLO_MS = 1000;

void setup() {
  pinMode(PIN_SEM1_VERDE, OUTPUT);
  pinMode(PIN_SEM1_AMARILLO, OUTPUT);
  pinMode(PIN_SEM1_ROJO, OUTPUT);
  pinMode(PIN_SEM2_VERDE, OUTPUT);
  pinMode(PIN_SEM2_AMARILLO, OUTPUT);
  pinMode(PIN_SEM2_ROJO, OUTPUT);
}

void loop() {
  // Cuadro 1: Semáforo 1 VERDE / Semáforo 2 ROJO.
  digitalWrite(PIN_SEM1_VERDE, HIGH);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, LOW);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_VERDE_MS);

  // Cuadro 2: Semáforo 1 AMARILLO / Semáforo 2 ROJO.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, HIGH);
  digitalWrite(PIN_SEM1_ROJO, LOW);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_AMARILLO_MS);

  // Cuadro 3: TODO ROJO — la intersección se vacía antes del cambio.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_TODO_ROJO_MS);

  // Cuadro 4: Semáforo 1 ROJO / Semáforo 2 ROJO + AMARILLO (por arrancar).
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, HIGH);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_ROJO_AMARILLO_MS);

  // Cuadro 5: Semáforo 1 ROJO / Semáforo 2 VERDE — ahora circula la otra calle.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, HIGH);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, LOW);
  delay(DURACION_VERDE_MS);

  // Cuadro 6: Semáforo 1 ROJO / Semáforo 2 AMARILLO.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, HIGH);
  digitalWrite(PIN_SEM2_ROJO, LOW);
  delay(DURACION_AMARILLO_MS);

  // Cuadro 7: TODO ROJO — otra vez el margen de seguridad.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, LOW);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_TODO_ROJO_MS);

  // Cuadro 8: Semáforo 1 ROJO + AMARILLO / Semáforo 2 ROJO.
  digitalWrite(PIN_SEM1_VERDE, LOW);
  digitalWrite(PIN_SEM1_AMARILLO, HIGH);
  digitalWrite(PIN_SEM1_ROJO, HIGH);
  digitalWrite(PIN_SEM2_VERDE, LOW);
  digitalWrite(PIN_SEM2_AMARILLO, LOW);
  digitalWrite(PIN_SEM2_ROJO, HIGH);
  delay(DURACION_ROJO_AMARILLO_MS);

  // loop() vuelve a empezar: el cuadro 9 del cómic es igual al cuadro 1.
}

// Parpadeo de un LED SIN delay(): código no bloqueante con millis().
//
// ¿Por qué? delay() "cuelga" el procesador: mientras espera, no puede
// atender botones, sensores ni la conexión a internet (clave para IoT).
// millis() funciona como un cronómetro que corre desde el encendido:
// en vez de detenernos a esperar, cada vuelta de loop() PREGUNTAMOS
// cuánto tiempo pasó y solo actuamos cuando corresponde.
//
// Plataforma: Arduino UNO (pin 13, LED integrado).
//
// Basado en: Fragmento de código 4 — Sistema de Semaforización,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas para pin e intervalo, y
// "millisAnterior" declarado como unsigned long (el original usaba long,
// que a los ~25 días de funcionamiento continuo desborda y rompe la cuenta;
// con unsigned long la resta millisActual - millisAnterior sigue siendo
// correcta incluso cuando millis() da la vuelta a los ~49 días).

const int PIN_LED = 13; // LED integrado del UNO

const unsigned long INTERVALO_PARPADEO_MS = 1000;

// Estado actual del LED (LOW = apagado, HIGH = encendido).
int estadoLed = LOW;

// Momento (en ms desde el arranque) en que conmutamos el LED por última vez.
unsigned long millisAnterior = 0;

void setup() {
  pinMode(PIN_LED, OUTPUT);
}

void loop() {
  unsigned long millisActual = millis();

  // ¿Ya pasó un segundo desde la última conmutación? Si no pasó,
  // no hacemos nada y loop() vuelve a empezar: eso es NO bloquear.
  if (millisActual - millisAnterior >= INTERVALO_PARPADEO_MS) {
    // Conmutar el estado del LED.
    if (estadoLed == LOW) {
      estadoLed = HIGH;
    } else {
      estadoLed = LOW;
    }

    digitalWrite(PIN_LED, estadoLed);

    // Guardamos "cuándo fue la última vez": así la próxima espera
    // se mide desde este momento y no desde el arranque.
    millisAnterior = millisActual;
  }

  // En este punto el procesador queda libre para realizar otras tareas
  // (leer sensores, atender la red, etc.) en cada vuelta de loop().
}

// Parpadeo de un LED SIN delay(): código no bloqueante con millis().
//
// ¿Por qué? delay() "cuelga" el procesador: mientras espera, no puede
// atender botones, sensores ni la conexión a internet (clave para IoT,
// y en el ESP32 el WiFi es justamente el plato fuerte). millis() funciona
// como un cronómetro que corre desde el encendido: en vez de detenernos
// a esperar, cada vuelta de loop() PREGUNTAMOS cuánto tiempo pasó y solo
// actuamos cuando corresponde.
//
// Plataforma: ESP32 (DevKit v1), GPIO 2 (LED azul integrado).
// Nota eléctrica: el ESP32 trabaja a 3,3 V (no 5 V como el UNO).
//
// Basado en: Fragmento de código 4 — Sistema de Semaforización,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: portado a ESP32; constantes nombradas para pin e
// intervalo, y "millisAnterior" declarado como unsigned long (el original
// usaba long, que desborda la cuenta; con unsigned long la resta
// millisActual - millisAnterior sigue siendo correcta incluso cuando
// millis() da la vuelta a los ~49 días).

const int PIN_LED = 2; // LED integrado del DevKit v1

const unsigned long INTERVALO_PARPADEO_MS = 1000;

// Estado actual del LED (LOW = apagado, HIGH = encendido).
int estadoLed = LOW;

// Momento (en ms desde el arranque) en que conmutamos el LED por última vez.
unsigned long millisAnterior = 0;

void setup() {
  pinMode(PIN_LED, OUTPUT);
}

void loop() {
  unsigned long millisActual = millis();

  // ¿Ya pasó un segundo desde la última conmutación? Si no pasó,
  // no hacemos nada y loop() vuelve a empezar: eso es NO bloquear.
  if (millisActual - millisAnterior >= INTERVALO_PARPADEO_MS) {
    // Conmutar el estado del LED.
    if (estadoLed == LOW) {
      estadoLed = HIGH;
    } else {
      estadoLed = LOW;
    }

    digitalWrite(PIN_LED, estadoLed);

    // Guardamos "cuándo fue la última vez": así la próxima espera
    // se mide desde este momento y no desde el arranque.
    millisAnterior = millisActual;
  }

  // En este punto el procesador queda libre para realizar otras tareas
  // (leer sensores, atender la red WiFi, etc.) en cada vuelta de loop().
}

// Intersección completa (6 LED) SIN delay(): máquina de estados con millis().
// Misma secuencia de 8 cuadros del nivel intermedio, pero no bloqueante:
// el procesador queda libre en cada vuelta de loop() para otras tareas
// (esta es la base sobre la que el nivel IoT agrega la conexión a internet).
//
//   Estado | Semáforo 1      | Semáforo 2      | Duración
//   -------+-----------------+-----------------+---------
//     1    | VERDE           | ROJO            |   5 s
//     2    | AMARILLO        | ROJO            |   1 s
//     3    | ROJO            | ROJO            |   1 s   (todo rojo)
//     4    | ROJO            | ROJO + AMARILLO |   1 s
//     5    | ROJO            | VERDE           |   5 s
//     6    | ROJO            | AMARILLO        |   1 s
//     7    | ROJO            | ROJO            |   1 s   (todo rojo)
//     8    | ROJO + AMARILLO | ROJO            |   1 s   → vuelve al 1
//
// Plataforma: Arduino UNO.
// Conexión: semáforo 1 → verde 11, amarillo 12, rojo 13;
//           semáforo 2 → verde 8, amarillo 9, rojo 10.
//
// Basado en: Fragmento de código 5 — Sistema de Semaforización,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) el original aplicaba la máquina de estados a UN solo
// semáforo; acá se extiende a la intersección completa de 6 LED manteniendo
// el estilo (if por estado + millisAnterior). (2) El original separaba cada
// paso en dos estados ("poner" y "esperando"); acá cada estado enciende sus
// luces AL ENTRAR (dentro del if de transición), lo que deja exactamente
// 8 estados: uno por cuadro del cómic de la Fig. 10. (3) unsigned long para
// los tiempos y una función auxiliar aplicarLuces() para escribir las seis
// luces de un cuadro completo de una sola vez.

// Semáforo 1 (calle principal).
const int PIN_SEM1_VERDE    = 11;
const int PIN_SEM1_AMARILLO = 12;
const int PIN_SEM1_ROJO     = 13;

// Semáforo 2 (calle transversal).
const int PIN_SEM2_VERDE    = 8;
const int PIN_SEM2_AMARILLO = 9;
const int PIN_SEM2_ROJO     = 10;

// Tiempos de la secuencia (los mismos de toda la guía y del simulador).
const unsigned long DURACION_VERDE_MS         = 5000;
const unsigned long DURACION_AMARILLO_MS      = 1000;
const unsigned long DURACION_TODO_ROJO_MS     = 1000; // margen de seguridad
const unsigned long DURACION_ROJO_AMARILLO_MS = 1000;

// Estado actual de la máquina (1 a 8, un estado por cuadro del cómic).
int estado = 1;

// Momento (ms desde el arranque) en que entramos al estado actual.
unsigned long millisAnterior = 0;

// Escribe las seis luces de un cuadro completo. Que cada estado defina
// TODAS las luces (y no solo las que cambian) evita que un cuadro dependa
// de lo que dejó encendido el anterior: cada estado se entiende solo.
// Orden de parámetros: semáforo 1 (verde, amarillo, rojo),
//                      semáforo 2 (verde, amarillo, rojo).
void aplicarLuces(int sem1Verde, int sem1Amarillo, int sem1Rojo,
                  int sem2Verde, int sem2Amarillo, int sem2Rojo) {
  digitalWrite(PIN_SEM1_VERDE, sem1Verde);
  digitalWrite(PIN_SEM1_AMARILLO, sem1Amarillo);
  digitalWrite(PIN_SEM1_ROJO, sem1Rojo);
  digitalWrite(PIN_SEM2_VERDE, sem2Verde);
  digitalWrite(PIN_SEM2_AMARILLO, sem2Amarillo);
  digitalWrite(PIN_SEM2_ROJO, sem2Rojo);
}

void setup() {
  pinMode(PIN_SEM1_VERDE, OUTPUT);
  pinMode(PIN_SEM1_AMARILLO, OUTPUT);
  pinMode(PIN_SEM1_ROJO, OUTPUT);
  pinMode(PIN_SEM2_VERDE, OUTPUT);
  pinMode(PIN_SEM2_AMARILLO, OUTPUT);
  pinMode(PIN_SEM2_ROJO, OUTPUT);

  // Encendemos las luces del estado inicial (cuadro 1): S1 verde / S2 rojo.
  aplicarLuces(HIGH, LOW, LOW, LOW, LOW, HIGH);
}

void loop() {
  unsigned long millisActual = millis();

  // Cada if pregunta: "¿estoy en el estado N y ya se cumplió su tiempo?"
  // Si la respuesta es sí, enciende las luces del estado siguiente,
  // guarda el momento del cambio y avanza. Si es no, no hace nada:
  // por eso este código es no bloqueante.

  // Estado 1 (S1 verde / S2 rojo): tras 5 s pasa al estado 2.
  if (estado == 1 && millisActual - millisAnterior >= DURACION_VERDE_MS) {
    aplicarLuces(LOW, HIGH, LOW, LOW, LOW, HIGH); // cuadro 2: S1 amarillo / S2 rojo
    millisAnterior = millisActual;
    estado = 2;
  }

  // Estado 2 (S1 amarillo / S2 rojo): tras 1 s pasa al estado 3.
  if (estado == 2 && millisActual - millisAnterior >= DURACION_AMARILLO_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, LOW, HIGH); // cuadro 3: todo rojo
    millisAnterior = millisActual;
    estado = 3;
  }

  // Estado 3 (todo rojo): tras 1 s pasa al estado 4.
  if (estado == 3 && millisActual - millisAnterior >= DURACION_TODO_ROJO_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, HIGH, HIGH); // cuadro 4: S2 rojo+amarillo
    millisAnterior = millisActual;
    estado = 4;
  }

  // Estado 4 (S1 rojo / S2 rojo+amarillo): tras 1 s pasa al estado 5.
  if (estado == 4 && millisActual - millisAnterior >= DURACION_ROJO_AMARILLO_MS) {
    aplicarLuces(LOW, LOW, HIGH, HIGH, LOW, LOW); // cuadro 5: S2 verde
    millisAnterior = millisActual;
    estado = 5;
  }

  // Estado 5 (S1 rojo / S2 verde): tras 5 s pasa al estado 6.
  if (estado == 5 && millisActual - millisAnterior >= DURACION_VERDE_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, HIGH, LOW); // cuadro 6: S2 amarillo
    millisAnterior = millisActual;
    estado = 6;
  }

  // Estado 6 (S1 rojo / S2 amarillo): tras 1 s pasa al estado 7.
  if (estado == 6 && millisActual - millisAnterior >= DURACION_AMARILLO_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, LOW, HIGH); // cuadro 7: todo rojo
    millisAnterior = millisActual;
    estado = 7;
  }

  // Estado 7 (todo rojo): tras 1 s pasa al estado 8.
  if (estado == 7 && millisActual - millisAnterior >= DURACION_TODO_ROJO_MS) {
    aplicarLuces(LOW, HIGH, HIGH, LOW, LOW, HIGH); // cuadro 8: S1 rojo+amarillo
    millisAnterior = millisActual;
    estado = 8;
  }

  // Estado 8 (S1 rojo+amarillo / S2 rojo): tras 1 s vuelve al estado 1.
  if (estado == 8 && millisActual - millisAnterior >= DURACION_ROJO_AMARILLO_MS) {
    aplicarLuces(HIGH, LOW, LOW, LOW, LOW, HIGH); // cuadro 1: S1 verde / S2 rojo
    millisAnterior = millisActual;
    estado = 1;
  }

  // En este punto el procesador queda libre para realizar otras tareas.
}

// Intersección completa (6 LED) SIN delay(): máquina de estados con millis().
// Misma secuencia de 8 cuadros del nivel intermedio, pero no bloqueante:
// el procesador queda libre en cada vuelta de loop() para otras tareas.
// Este programa es la base directa de semaforo-iot.ino: sin código
// bloqueante, el ESP32 puede mantener el WiFi y publicar por MQTT
// sin que el semáforo se "cuelgue".
//
//   Estado | Semáforo 1      | Semáforo 2      | Duración
//   -------+-----------------+-----------------+---------
//     1    | VERDE           | ROJO            |   5 s
//     2    | AMARILLO        | ROJO            |   1 s
//     3    | ROJO            | ROJO            |   1 s   (todo rojo)
//     4    | ROJO            | ROJO + AMARILLO |   1 s
//     5    | ROJO            | VERDE           |   5 s
//     6    | ROJO            | AMARILLO        |   1 s
//     7    | ROJO            | ROJO            |   1 s   (todo rojo)
//     8    | ROJO + AMARILLO | ROJO            |   1 s   → vuelve al 1
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: semáforo 1 → verde GPIO 16, amarillo GPIO 17, rojo GPIO 18;
//           semáforo 2 → verde GPIO 19, amarillo GPIO 21, rojo GPIO 22.
// Nota eléctrica: el ESP32 trabaja a 3,3 V (no 5 V como el UNO); nunca
// inyectar 5 V en un GPIO.
//
// Basado en: Fragmento de código 5 — Sistema de Semaforización,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) el original aplicaba la máquina de estados a UN solo
// semáforo; acá se extiende a la intersección completa de 6 LED manteniendo
// el estilo (if por estado + millisAnterior). (2) El original separaba cada
// paso en dos estados ("poner" y "esperando"); acá cada estado enciende sus
// luces AL ENTRAR (dentro del if de transición), lo que deja exactamente
// 8 estados: uno por cuadro del cómic de la Fig. 10. (3) unsigned long para
// los tiempos, GPIO seguros de ESP32 y una función auxiliar aplicarLuces()
// para escribir las seis luces de un cuadro completo de una sola vez.

// Semáforo 1 (calle principal).
const int PIN_SEM1_VERDE    = 16;
const int PIN_SEM1_AMARILLO = 17;
const int PIN_SEM1_ROJO     = 18;

// Semáforo 2 (calle transversal).
const int PIN_SEM2_VERDE    = 19;
const int PIN_SEM2_AMARILLO = 21;
const int PIN_SEM2_ROJO     = 22;

// Tiempos de la secuencia (los mismos de toda la guía y del simulador).
const unsigned long DURACION_VERDE_MS         = 5000;
const unsigned long DURACION_AMARILLO_MS      = 1000;
const unsigned long DURACION_TODO_ROJO_MS     = 1000; // margen de seguridad
const unsigned long DURACION_ROJO_AMARILLO_MS = 1000;

// Estado actual de la máquina (1 a 8, un estado por cuadro del cómic).
int estado = 1;

// Momento (ms desde el arranque) en que entramos al estado actual.
unsigned long millisAnterior = 0;

// Escribe las seis luces de un cuadro completo. Que cada estado defina
// TODAS las luces (y no solo las que cambian) evita que un cuadro dependa
// de lo que dejó encendido el anterior: cada estado se entiende solo.
// Orden de parámetros: semáforo 1 (verde, amarillo, rojo),
//                      semáforo 2 (verde, amarillo, rojo).
void aplicarLuces(int sem1Verde, int sem1Amarillo, int sem1Rojo,
                  int sem2Verde, int sem2Amarillo, int sem2Rojo) {
  digitalWrite(PIN_SEM1_VERDE, sem1Verde);
  digitalWrite(PIN_SEM1_AMARILLO, sem1Amarillo);
  digitalWrite(PIN_SEM1_ROJO, sem1Rojo);
  digitalWrite(PIN_SEM2_VERDE, sem2Verde);
  digitalWrite(PIN_SEM2_AMARILLO, sem2Amarillo);
  digitalWrite(PIN_SEM2_ROJO, sem2Rojo);
}

void setup() {
  pinMode(PIN_SEM1_VERDE, OUTPUT);
  pinMode(PIN_SEM1_AMARILLO, OUTPUT);
  pinMode(PIN_SEM1_ROJO, OUTPUT);
  pinMode(PIN_SEM2_VERDE, OUTPUT);
  pinMode(PIN_SEM2_AMARILLO, OUTPUT);
  pinMode(PIN_SEM2_ROJO, OUTPUT);

  // Encendemos las luces del estado inicial (cuadro 1): S1 verde / S2 rojo.
  aplicarLuces(HIGH, LOW, LOW, LOW, LOW, HIGH);
}

void loop() {
  unsigned long millisActual = millis();

  // Cada if pregunta: "¿estoy en el estado N y ya se cumplió su tiempo?"
  // Si la respuesta es sí, enciende las luces del estado siguiente,
  // guarda el momento del cambio y avanza. Si es no, no hace nada:
  // por eso este código es no bloqueante.

  // Estado 1 (S1 verde / S2 rojo): tras 5 s pasa al estado 2.
  if (estado == 1 && millisActual - millisAnterior >= DURACION_VERDE_MS) {
    aplicarLuces(LOW, HIGH, LOW, LOW, LOW, HIGH); // cuadro 2: S1 amarillo / S2 rojo
    millisAnterior = millisActual;
    estado = 2;
  }

  // Estado 2 (S1 amarillo / S2 rojo): tras 1 s pasa al estado 3.
  if (estado == 2 && millisActual - millisAnterior >= DURACION_AMARILLO_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, LOW, HIGH); // cuadro 3: todo rojo
    millisAnterior = millisActual;
    estado = 3;
  }

  // Estado 3 (todo rojo): tras 1 s pasa al estado 4.
  if (estado == 3 && millisActual - millisAnterior >= DURACION_TODO_ROJO_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, HIGH, HIGH); // cuadro 4: S2 rojo+amarillo
    millisAnterior = millisActual;
    estado = 4;
  }

  // Estado 4 (S1 rojo / S2 rojo+amarillo): tras 1 s pasa al estado 5.
  if (estado == 4 && millisActual - millisAnterior >= DURACION_ROJO_AMARILLO_MS) {
    aplicarLuces(LOW, LOW, HIGH, HIGH, LOW, LOW); // cuadro 5: S2 verde
    millisAnterior = millisActual;
    estado = 5;
  }

  // Estado 5 (S1 rojo / S2 verde): tras 5 s pasa al estado 6.
  if (estado == 5 && millisActual - millisAnterior >= DURACION_VERDE_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, HIGH, LOW); // cuadro 6: S2 amarillo
    millisAnterior = millisActual;
    estado = 6;
  }

  // Estado 6 (S1 rojo / S2 amarillo): tras 1 s pasa al estado 7.
  if (estado == 6 && millisActual - millisAnterior >= DURACION_AMARILLO_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, LOW, HIGH); // cuadro 7: todo rojo
    millisAnterior = millisActual;
    estado = 7;
  }

  // Estado 7 (todo rojo): tras 1 s pasa al estado 8.
  if (estado == 7 && millisActual - millisAnterior >= DURACION_TODO_ROJO_MS) {
    aplicarLuces(LOW, HIGH, HIGH, LOW, LOW, HIGH); // cuadro 8: S1 rojo+amarillo
    millisAnterior = millisActual;
    estado = 8;
  }

  // Estado 8 (S1 rojo+amarillo / S2 rojo): tras 1 s vuelve al estado 1.
  if (estado == 8 && millisActual - millisAnterior >= DURACION_ROJO_AMARILLO_MS) {
    aplicarLuces(HIGH, LOW, LOW, LOW, LOW, HIGH); // cuadro 1: S1 verde / S2 rojo
    millisAnterior = millisActual;
    estado = 1;
  }

  // En este punto el procesador queda libre para realizar otras tareas
  // (en semaforo-iot.ino, acá se atiende la conexión WiFi/MQTT).
}

// Intersección completa (6 LED) con monitoreo IoT vía Adafruit IO (MQTT).
// La máquina de estados de semaforo-no-bloqueante.ino sigue manejando las
// luces; además, cada vez que un semáforo cambia de color, se publica su
// nuevo estado en un "feed" de Adafruit IO para verlo desde el Panel de
// Control (la "central de monitoreo") en cualquier dispositivo con internet.
//
// Convención de códigos publicados: 1 = verde, 2 = amarillo, 3 = rojo.
// Durante rojo + amarillo también se publica 3 (ver constantes más abajo).
// Feeds: "semaforo1" (calle principal) y "semaforo2" (calle transversal).
//
// Plataforma: ESP32 (DevKit v1) — usa su WiFi integrado.
// Conexión: semáforo 1 → verde GPIO 16, amarillo GPIO 17, rojo GPIO 18;
//           semáforo 2 → verde GPIO 19, amarillo GPIO 21, rojo GPIO 22.
// Nota eléctrica: el ESP32 trabaja a 3,3 V (no 5 V como el UNO); nunca
// inyectar 5 V en un GPIO.
//
// Librería requerida (Library Manager del IDE de Arduino):
//   "Adafruit MQTT Library" (de Adafruit). Se eligió porque cada feed se
//   representa como un objeto y publish() acepta números directamente,
//   igual que el olq.publish() del original; con PubSubClient habría que
//   armar a mano los topics y convertir los números a texto.
//
// Basado en: Fragmento de código 6 — Sistema de Semaforización,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) el módulo OBLOQ y la librería ObloqAdafruit quedaron
// discontinuados; se reemplazan por el WiFi nativo del ESP32 (WiFi.h) y un
// cliente MQTT estándar contra io.adafruit.com. (2) La máquina de estados
// se extiende del semáforo único del original a la intersección completa
// de 6 LED con dos feeds. (3) Se publica SOLO cuando un semáforo cambia de
// color: publicar en cada vuelta de loop() saturaría el límite gratuito de
// Adafruit IO (30 publicaciones por minuto; este ciclo genera 8 cada 16 s,
// justo al límite — si Adafruit avisa "throttled", alargá las duraciones).

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

// ---------------------------------------------------------------------------
// Credenciales: reemplazar los cuatro valores por los propios.
// El usuario y la key de Adafruit se copian desde io.adafruit.com
// haciendo clic en el ícono de la "llave" (igual que en la guía original).
// ---------------------------------------------------------------------------
#define WIFI_SSID     "TU_SSID"
#define WIFI_PASSWORD "TU_PASSWORD"
#define IO_USERNAME   "TU_USUARIO_ADAFRUIT"
#define IO_KEY        "TU_KEY_ADAFRUIT"

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

// Semáforo 1 (calle principal).
const int PIN_SEM1_VERDE    = 16;
const int PIN_SEM1_AMARILLO = 17;
const int PIN_SEM1_ROJO     = 18;

// Semáforo 2 (calle transversal).
const int PIN_SEM2_VERDE    = 19;
const int PIN_SEM2_AMARILLO = 21;
const int PIN_SEM2_ROJO     = 22;

// Tiempos de la secuencia (los mismos de toda la guía y del simulador).
const unsigned long DURACION_VERDE_MS         = 5000;
const unsigned long DURACION_AMARILLO_MS      = 1000;
const unsigned long DURACION_TODO_ROJO_MS     = 1000; // margen de seguridad
const unsigned long DURACION_ROJO_AMARILLO_MS = 1000;

// Si se cae la conexión MQTT, reintentamos cada tanto SIN bloquear:
// el semáforo debe seguir funcionando aunque no haya internet.
const unsigned long INTERVALO_REINTENTO_MQTT_MS = 5000;

// Códigos de estado que se publican (convención del original: 1/2/3).
// Modernización: el original publicaba 4 en rojo+amarillo, pero su panel
// solo mapeaba 1/2/3 y quedaba gris. Como el rojo sigue encendido en esa
// fase, publicamos 3 y el panel refleja siempre un estado real.
const int CODIGO_VERDE         = 1;
const int CODIGO_AMARILLO      = 2;
const int CODIGO_ROJO          = 3;
const int CODIGO_ROJO_AMARILLO = CODIGO_ROJO;

// Cliente MQTT sobre el WiFi del ESP32, y un objeto por feed.
WiFiClient clienteWifi;
Adafruit_MQTT_Client mqtt(&clienteWifi, SERVIDOR_MQTT, PUERTO_MQTT,
                          IO_USERNAME, IO_KEY);
Adafruit_MQTT_Publish feedSemaforo1(&mqtt, IO_USERNAME "/feeds/semaforo1");
Adafruit_MQTT_Publish feedSemaforo2(&mqtt, IO_USERNAME "/feeds/semaforo2");

// Estado actual de la máquina (1 a 8, un estado por cuadro del cómic).
int estado = 1;

// Momento (ms desde el arranque) en que entramos al estado actual.
unsigned long millisAnterior = 0;

// Momento del último intento de conexión MQTT.
unsigned long millisUltimoIntentoMqtt = 0;

// Color actual de cada semáforo y último color que llegó a publicarse.
// Separarlos permite publicar solo los CAMBIOS y, si la conexión estaba
// caída durante un cambio, ponerse al día apenas vuelva.
int codigoSem1 = CODIGO_VERDE;
int codigoSem2 = CODIGO_ROJO;
int codigoSem1Publicado = 0; // 0 = todavía no se publicó nada
int codigoSem2Publicado = 0;

// Escribe las seis luces de un cuadro completo (ver semaforo-no-bloqueante.ino).
// Orden: semáforo 1 (verde, amarillo, rojo), semáforo 2 (verde, amarillo, rojo).
void aplicarLuces(int sem1Verde, int sem1Amarillo, int sem1Rojo,
                  int sem2Verde, int sem2Amarillo, int sem2Rojo) {
  digitalWrite(PIN_SEM1_VERDE, sem1Verde);
  digitalWrite(PIN_SEM1_AMARILLO, sem1Amarillo);
  digitalWrite(PIN_SEM1_ROJO, sem1Rojo);
  digitalWrite(PIN_SEM2_VERDE, sem2Verde);
  digitalWrite(PIN_SEM2_AMARILLO, sem2Amarillo);
  digitalWrite(PIN_SEM2_ROJO, sem2Rojo);
}

// Mantiene viva la conexión MQTT sin bloquear el semáforo: si está caída,
// intenta reconectar como mucho una vez cada INTERVALO_REINTENTO_MQTT_MS.
void mantenerConexionMqtt() {
  if (mqtt.connected()) {
    return;
  }

  unsigned long millisActual = millis();
  if (millisActual - millisUltimoIntentoMqtt < INTERVALO_REINTENTO_MQTT_MS) {
    return; // todavía no toca reintentar
  }
  millisUltimoIntentoMqtt = millisActual;

  Serial.print("Conectando a Adafruit IO... ");
  int8_t resultado = mqtt.connect(); // 0 = conexión exitosa
  if (resultado == 0) {
    Serial.println("conectado.");
  } else {
    Serial.println(mqtt.connectErrorString(resultado));
    mqtt.disconnect(); // deja el socket limpio para el próximo intento
  }
}

// Publica en cada feed SOLO si el color cambió desde la última publicación
// exitosa. Si publish() falla (o no hay conexión), no actualizamos el
// registro: se reintentará en la próxima vuelta de loop().
void publicarCambios() {
  if (!mqtt.connected()) {
    return; // sin internet el semáforo sigue; la central se actualiza al volver
  }

  if (codigoSem1 != codigoSem1Publicado) {
    if (feedSemaforo1.publish((int32_t)codigoSem1)) {
      codigoSem1Publicado = codigoSem1;
    }
  }

  if (codigoSem2 != codigoSem2Publicado) {
    if (feedSemaforo2.publish((int32_t)codigoSem2)) {
      codigoSem2Publicado = codigoSem2;
    }
  }
}

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

  pinMode(PIN_SEM1_VERDE, OUTPUT);
  pinMode(PIN_SEM1_AMARILLO, OUTPUT);
  pinMode(PIN_SEM1_ROJO, OUTPUT);
  pinMode(PIN_SEM2_VERDE, OUTPUT);
  pinMode(PIN_SEM2_AMARILLO, OUTPUT);
  pinMode(PIN_SEM2_ROJO, OUTPUT);

  // Encendemos las luces del estado inicial (cuadro 1): S1 verde / S2 rojo.
  aplicarLuces(HIGH, LOW, LOW, LOW, LOW, HIGH);

  // Conexión WiFi. Esperar acá con delay() es aceptable porque el semáforo
  // todavía no arrancó su ciclo; una vez dentro de 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() {
  unsigned long millisActual = millis();

  // --- Máquina de estados de la intersección (8 cuadros del cómic) ---
  // Cada transición enciende las luces del estado siguiente y anota qué
  // color muestra ahora cada semáforo; la publicación se hace más abajo.

  // Estado 1 (S1 verde / S2 rojo): tras 5 s pasa al estado 2.
  if (estado == 1 && millisActual - millisAnterior >= DURACION_VERDE_MS) {
    aplicarLuces(LOW, HIGH, LOW, LOW, LOW, HIGH); // cuadro 2: S1 amarillo / S2 rojo
    codigoSem1 = CODIGO_AMARILLO;
    codigoSem2 = CODIGO_ROJO;
    millisAnterior = millisActual;
    estado = 2;
  }

  // Estado 2 (S1 amarillo / S2 rojo): tras 1 s pasa al estado 3.
  if (estado == 2 && millisActual - millisAnterior >= DURACION_AMARILLO_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, LOW, HIGH); // cuadro 3: todo rojo
    codigoSem1 = CODIGO_ROJO;
    codigoSem2 = CODIGO_ROJO;
    millisAnterior = millisActual;
    estado = 3;
  }

  // Estado 3 (todo rojo): tras 1 s pasa al estado 4.
  if (estado == 3 && millisActual - millisAnterior >= DURACION_TODO_ROJO_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, HIGH, HIGH); // cuadro 4: S2 rojo+amarillo
    codigoSem1 = CODIGO_ROJO;
    codigoSem2 = CODIGO_ROJO_AMARILLO;
    millisAnterior = millisActual;
    estado = 4;
  }

  // Estado 4 (S1 rojo / S2 rojo+amarillo): tras 1 s pasa al estado 5.
  if (estado == 4 && millisActual - millisAnterior >= DURACION_ROJO_AMARILLO_MS) {
    aplicarLuces(LOW, LOW, HIGH, HIGH, LOW, LOW); // cuadro 5: S2 verde
    codigoSem1 = CODIGO_ROJO;
    codigoSem2 = CODIGO_VERDE;
    millisAnterior = millisActual;
    estado = 5;
  }

  // Estado 5 (S1 rojo / S2 verde): tras 5 s pasa al estado 6.
  if (estado == 5 && millisActual - millisAnterior >= DURACION_VERDE_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, HIGH, LOW); // cuadro 6: S2 amarillo
    codigoSem1 = CODIGO_ROJO;
    codigoSem2 = CODIGO_AMARILLO;
    millisAnterior = millisActual;
    estado = 6;
  }

  // Estado 6 (S1 rojo / S2 amarillo): tras 1 s pasa al estado 7.
  if (estado == 6 && millisActual - millisAnterior >= DURACION_AMARILLO_MS) {
    aplicarLuces(LOW, LOW, HIGH, LOW, LOW, HIGH); // cuadro 7: todo rojo
    codigoSem1 = CODIGO_ROJO;
    codigoSem2 = CODIGO_ROJO;
    millisAnterior = millisActual;
    estado = 7;
  }

  // Estado 7 (todo rojo): tras 1 s pasa al estado 8.
  if (estado == 7 && millisActual - millisAnterior >= DURACION_TODO_ROJO_MS) {
    aplicarLuces(LOW, HIGH, HIGH, LOW, LOW, HIGH); // cuadro 8: S1 rojo+amarillo
    codigoSem1 = CODIGO_ROJO_AMARILLO;
    codigoSem2 = CODIGO_ROJO;
    millisAnterior = millisActual;
    estado = 8;
  }

  // Estado 8 (S1 rojo+amarillo / S2 rojo): tras 1 s vuelve al estado 1.
  if (estado == 8 && millisActual - millisAnterior >= DURACION_ROJO_AMARILLO_MS) {
    aplicarLuces(HIGH, LOW, LOW, LOW, LOW, HIGH); // cuadro 1: S1 verde / S2 rojo
    codigoSem1 = CODIGO_VERDE;
    codigoSem2 = CODIGO_ROJO;
    millisAnterior = millisActual;
    estado = 1;
  }

  // --- Parte IoT ---
  // Gracias a que la máquina de estados no bloquea, estas dos tareas se
  // atienden en CADA vuelta de loop(): esta es la razón de fondo por la
  // que la guía enseña a abandonar delay() antes de llegar a IoT.
  mantenerConexionMqtt();
  publicarCambios();
}