Cerradura Automatizada

// Cerradura automatizada — Nivel Inicial (Arduino UNO).
//
// Dos pulsadores controlan el servomotor que traba/destraba la cerradura:
//   - Pulsador ABRIR  -> el servo va a la posicion "abierta"  + LED verde.
//   - Pulsador CERRAR -> el servo va a la posicion "cerrada"  + LED rojo.
// Los LED indican de un vistazo el estado de la puerta (verde = abierta,
// rojo = cerrada), tal como pide la situacion-problema del abuelo de Josefina.
//
// Plataforma: Arduino UNO. Proyecto de BAJA TENSION (servo 5 V, LED,
// pulsadores): no hay 220 V ni agua, no lleva advertencias electricas.
//
// Nivel inicial: se permite delay() (fiel a la progresion original); el
// antirrebote se resuelve con una espera corta. El nivel avanzado pasa a
// millis() sin bloquear.
//
// Basado en: Fragmentos de codigo del Nivel Inicial (Pasos 2 y 5) — Cerradura
// Automatica, Saberes Digitales (INET/EDUCAR 2019).
// Desvios respecto del original (ver README):
//  (1) PINES UNIFICADOS: el original ataba el servo al pin 0 (rompe USB/serial)
//      y usaba pines de LED distintos por nivel. Aca el servo va al pin 10 y
//      los LED a 11/13 — el MISMO esquema en los tres niveles.
//  (2) Angulos del servo unificados (ABIERTA=90, CERRADA=0) para que el mismo
//      criterio valga en inicial, intermedio y avanzado.
//  (3) Pulsadores con INPUT_PULLUP (activo en LOW): el original leia entradas
//      "al aire"; el pull-up interno evita lecturas erraticas sin resistencias.

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

// --- Pines (esquema UNIFICADO del contrato) ---
const int PIN_SERVO      = 10;  // senal del servomotor de la cerradura
const int PIN_LED_VERDE  = 11;  // encendido = cerradura ABIERTA
const int PIN_LED_ROJO   = 13;  // encendido = cerradura CERRADA
// En el nivel inicial NO hay teclado, asi que los botones ocupan dos pines
// libres (2 y 3). En intermedio, el teclado matricial los reemplaza.
const int PIN_BOTON_ABRIR  = 2;
const int PIN_BOTON_CERRAR = 3;

// Angulos del servo (unificados en los tres niveles).
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// Antirrebote simple del pulsador (ms).
const unsigned long ANTIRREBOTE_MS = 200;

Servo cerradura;

void abrirPuerta() {
  cerradura.write(ANGULO_ABIERTA);
  digitalWrite(PIN_LED_VERDE, HIGH);
  digitalWrite(PIN_LED_ROJO, LOW);
}

void cerrarPuerta() {
  cerradura.write(ANGULO_CERRADA);
  digitalWrite(PIN_LED_VERDE, LOW);
  digitalWrite(PIN_LED_ROJO, HIGH);
}

void setup() {
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);
  // Con INPUT_PULLUP el pulsador lee HIGH en reposo y LOW al presionarse.
  pinMode(PIN_BOTON_ABRIR, INPUT_PULLUP);
  pinMode(PIN_BOTON_CERRAR, INPUT_PULLUP);

  cerradura.attach(PIN_SERVO);
  // Estado inicial: CERRADA (LED rojo). Es el estado seguro por defecto de
  // una cerradura.
  cerrarPuerta();
}

void loop() {
  // Pulsador presionado = LOW (por el pull-up interno).
  if (digitalRead(PIN_BOTON_ABRIR) == LOW) {
    abrirPuerta();
    delay(ANTIRREBOTE_MS);
  }

  if (digitalRead(PIN_BOTON_CERRAR) == LOW) {
    cerrarPuerta();
    delay(ANTIRREBOTE_MS);
  }
}

// Cerradura automatizada — Nivel Inicial (ESP32 DevKit v1).
//
// Dos pulsadores controlan el servomotor que traba/destraba la cerradura:
//   - Pulsador ABRIR  -> el servo va a la posicion "abierta"  + LED verde.
//   - Pulsador CERRAR -> el servo va a la posicion "cerrada"  + LED rojo.
// Los LED indican de un vistazo el estado (verde = abierta, rojo = cerrada).
//
// Plataforma: ESP32 (DevKit v1). El servo se maneja con la libreria
// ESP32Servo (la Servo.h clasica no funciona en ESP32). Nota electrica: el
// ESP32 trabaja a 3,3 V (el UNO a 5 V); alimentar el servo desde 5 V con GND
// comun. Proyecto de BAJA TENSION: sin 220 V ni agua.
//
// Nivel inicial: se permite delay() (fiel a la progresion original).
//
// Basado en: Fragmentos de codigo del Nivel Inicial (Pasos 2 y 5) — Cerradura
// Automatica, Saberes Digitales (INET/EDUCAR 2019).
// Desvios (ver README): pines GPIO seguros del contrato; angulos del servo
// unificados (ABIERTA=90, CERRADA=0); pulsadores con INPUT_PULLUP.

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

// --- Pines (GPIO seguros del contrato) ---
const int PIN_SERVO      = 13;  // ESP32Servo
const int PIN_LED_VERDE  = 25;  // encendido = cerradura ABIERTA
const int PIN_LED_ROJO   = 26;  // encendido = cerradura CERRADA
// En el nivel inicial no hay teclado: los botones ocupan dos GPIO libres de
// entrada (32 y 33). En intermedio los reemplaza el teclado matricial.
const int PIN_BOTON_ABRIR  = 32;
const int PIN_BOTON_CERRAR = 33;

// Angulos del servo (unificados en los tres niveles).
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// Antirrebote simple del pulsador (ms).
const unsigned long ANTIRREBOTE_MS = 200;

Servo cerradura;

void abrirPuerta() {
  cerradura.write(ANGULO_ABIERTA);
  digitalWrite(PIN_LED_VERDE, HIGH);
  digitalWrite(PIN_LED_ROJO, LOW);
}

void cerrarPuerta() {
  cerradura.write(ANGULO_CERRADA);
  digitalWrite(PIN_LED_VERDE, LOW);
  digitalWrite(PIN_LED_ROJO, HIGH);
}

void setup() {
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);
  // Con INPUT_PULLUP el pulsador lee HIGH en reposo y LOW al presionarse.
  pinMode(PIN_BOTON_ABRIR, INPUT_PULLUP);
  pinMode(PIN_BOTON_CERRAR, INPUT_PULLUP);

  cerradura.attach(PIN_SERVO);
  // Estado inicial: CERRADA (LED rojo), estado seguro por defecto.
  cerrarPuerta();
}

void loop() {
  // Pulsador presionado = LOW (por el pull-up interno).
  if (digitalRead(PIN_BOTON_ABRIR) == LOW) {
    abrirPuerta();
    delay(ANTIRREBOTE_MS);
  }

  if (digitalRead(PIN_BOTON_CERRAR) == LOW) {
    cerrarPuerta();
    delay(ANTIRREBOTE_MS);
  }
}

// Cerradura automatizada — Nivel Intermedio (Arduino UNO).
//
// Se reemplazan los dos pulsadores por un TECLADO MATRICIAL 4x4 y se suma un
// ZUMBADOR (buzzer). El usuario tipea una clave de 4 digitos; si coincide con
// la clave guardada, la cerradura conmuta su estado (abre si estaba cerrada,
// cierra si estaba abierta) y suena un pitido de OK. Si la clave es incorrecta,
// suena un doble pitido de error y no se mueve la cerradura. Los LED siguen
// indicando el estado (verde = abierta, rojo = cerrada), como pidio el abuelo.
//
// Clave del original: '1' '5' '9' 'D'.
//
// Plataforma: Arduino UNO. Proyecto de BAJA TENSION (servo 5 V, teclado, LED,
// buzzer): sin 220 V ni agua.
//
// Nivel intermedio: se permite delay() (fiel al original) para los pitidos.
//
// Basado en: Fragmento de codigo del Nivel Intermedio (Paso 3) — Cerradura
// Automatica, Saberes Digitales (INET/EDUCAR 2019).
// Desvios respecto del original (ver README):
//  (1) PINES UNIFICADOS: servo=10, LED verde=11, buzzer=12, LED rojo=13, y el
//      teclado en filas {9,8,7,6} / columnas {5,4,3,2} — el MISMO esquema que
//      inicial y avanzado (el original cambiaba pines entre niveles).
//  (2) BUZZER con tone(): el original prendia/apagaba el buzzer con
//      digitalWrite (un buzzer "activo"); tone() genera una frecuencia audible
//      y sirve para cualquier buzzer, ademas de permitir distinguir el tono de
//      OK del de error.
//  (3) Angulos del servo unificados (ABIERTA=90, CERRADA=0). El sistema arranca
//      CERRADO (LED rojo), estado seguro por defecto.

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

// --- Pines (esquema UNIFICADO del contrato) ---
const int PIN_SERVO     = 10;
const int PIN_LED_VERDE = 11;  // encendido = ABIERTA
const int PIN_BUZZER    = 12;
const int PIN_LED_ROJO  = 13;  // encendido = CERRADA

// Angulos del servo (unificados en los tres niveles).
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// --- Teclado matricial 4x4 ---
const byte FILAS    = 4;
const byte COLUMNAS = 4;
char teclas[FILAS][COLUMNAS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte pinesFilas[FILAS]       = {9, 8, 7, 6};
byte pinesColumnas[COLUMNAS] = {5, 4, 3, 2};
Keypad teclado = Keypad(makeKeymap(teclas), pinesFilas, pinesColumnas,
                        FILAS, COLUMNAS);

// --- Clave (la del original) y buffer de lo tecleado ---
const byte LARGO_CLAVE = 4;
char clave[LARGO_CLAVE]    = {'1', '5', '9', 'D'};
char tecleado[LARGO_CLAVE] = {0, 0, 0, 0};
byte indice = 0;

// --- Buzzer: tonos distintos para OK y error ---
const unsigned int FREQ_OK        = 1000;  // Hz, pitido agudo = correcta
const unsigned int FREQ_ERROR     = 400;   // Hz, pitido grave = incorrecta
const unsigned long DURACION_BEEP_MS = 200;
const unsigned long PAUSA_BEEP_MS    = 300;

// Estado de la puerta: true = abierta, false = cerrada.
bool puertaAbierta = false;

Servo cerradura;

void mostrarEstadoEnLeds() {
  digitalWrite(PIN_LED_VERDE, puertaAbierta ? HIGH : LOW);
  digitalWrite(PIN_LED_ROJO, puertaAbierta ? LOW : HIGH);
}

void beepCorrecta() {
  tone(PIN_BUZZER, FREQ_OK, DURACION_BEEP_MS);
  delay(DURACION_BEEP_MS);
  noTone(PIN_BUZZER);
}

void beepIncorrecta() {
  // Doble pitido grave.
  for (byte i = 0; i < 2; i++) {
    tone(PIN_BUZZER, FREQ_ERROR, DURACION_BEEP_MS);
    delay(DURACION_BEEP_MS);
    noTone(PIN_BUZZER);
    delay(PAUSA_BEEP_MS);
  }
}

// Compara lo tecleado con la clave guardada.
bool claveCorrecta() {
  for (byte i = 0; i < LARGO_CLAVE; i++) {
    if (tecleado[i] != clave[i]) {
      return false;
    }
  }
  return true;
}

void setup() {
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);
  pinMode(PIN_BUZZER, OUTPUT);

  cerradura.attach(PIN_SERVO);
  // Arranca CERRADA (LED rojo).
  puertaAbierta = false;
  cerradura.write(ANGULO_CERRADA);
  mostrarEstadoEnLeds();
}

void loop() {
  char tecla = teclado.getKey();
  if (!tecla) {
    return;  // no se presiono ninguna tecla en esta vuelta
  }

  // Guarda la tecla y avanza el indice.
  tecleado[indice] = tecla;
  indice++;

  // Cuando se completan 4 digitos, se evalua la clave.
  if (indice == LARGO_CLAVE) {
    indice = 0;

    if (claveCorrecta()) {
      beepCorrecta();
      // Conmuta el estado de la cerradura.
      puertaAbierta = !puertaAbierta;
      cerradura.write(puertaAbierta ? ANGULO_ABIERTA : ANGULO_CERRADA);
      mostrarEstadoEnLeds();
    } else {
      beepIncorrecta();  // no toca la cerradura
    }
  }
}

// Cerradura automatizada — Nivel Intermedio (ESP32 DevKit v1).
//
// Se reemplazan los dos pulsadores por un TECLADO MATRICIAL 4x4 y se suma un
// ZUMBADOR (buzzer). El usuario tipea una clave de 4 digitos; si coincide con
// la clave guardada, la cerradura conmuta su estado (abre si estaba cerrada,
// cierra si estaba abierta) y suena un pitido de OK. Si es incorrecta, suena
// un doble pitido de error y la cerradura no se mueve. Los LED indican el
// estado (verde = abierta, rojo = cerrada).
//
// Clave del original: '1' '5' '9' 'D'.
//
// Plataforma: ESP32 (DevKit v1). Servo con ESP32Servo; el buzzer usa tone(),
// disponible en el core de ESP32. Nota electrica: el ESP32 trabaja a 3,3 V
// (alimentar el servo desde 5 V con GND comun). Proyecto de BAJA TENSION.
//
// Nivel intermedio: se permite delay() (fiel al original) para los pitidos.
//
// Basado en: Fragmento de codigo del Nivel Intermedio (Paso 3) — Cerradura
// Automatica, Saberes Digitales (INET/EDUCAR 2019).
// Desvios (ver README): pines GPIO seguros del contrato; buzzer con tone();
// angulos unificados (ABIERTA=90, CERRADA=0); arranque CERRADO (LED rojo).

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

// --- Pines (GPIO seguros del contrato) ---
const int PIN_SERVO     = 13;
const int PIN_LED_VERDE = 25;  // encendido = ABIERTA
const int PIN_LED_ROJO  = 26;  // encendido = CERRADA
const int PIN_BUZZER    = 14;

// Angulos del servo (unificados en los tres niveles).
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// --- Teclado matricial 4x4 ---
const byte FILAS    = 4;
const byte COLUMNAS = 4;
char teclas[FILAS][COLUMNAS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte pinesFilas[FILAS]       = {16, 17, 18, 19};
byte pinesColumnas[COLUMNAS] = {21, 22, 23, 27};
Keypad teclado = Keypad(makeKeymap(teclas), pinesFilas, pinesColumnas,
                        FILAS, COLUMNAS);

// --- Clave (la del original) y buffer de lo tecleado ---
const byte LARGO_CLAVE = 4;
char clave[LARGO_CLAVE]    = {'1', '5', '9', 'D'};
char tecleado[LARGO_CLAVE] = {0, 0, 0, 0};
byte indice = 0;

// --- Buzzer: tonos distintos para OK y error ---
const unsigned int FREQ_OK        = 1000;  // Hz, pitido agudo = correcta
const unsigned int FREQ_ERROR     = 400;   // Hz, pitido grave = incorrecta
const unsigned long DURACION_BEEP_MS = 200;
const unsigned long PAUSA_BEEP_MS    = 300;

// Estado de la puerta: true = abierta, false = cerrada.
bool puertaAbierta = false;

Servo cerradura;

void mostrarEstadoEnLeds() {
  digitalWrite(PIN_LED_VERDE, puertaAbierta ? HIGH : LOW);
  digitalWrite(PIN_LED_ROJO, puertaAbierta ? LOW : HIGH);
}

void beepCorrecta() {
  tone(PIN_BUZZER, FREQ_OK, DURACION_BEEP_MS);
  delay(DURACION_BEEP_MS);
  noTone(PIN_BUZZER);
}

void beepIncorrecta() {
  // Doble pitido grave.
  for (byte i = 0; i < 2; i++) {
    tone(PIN_BUZZER, FREQ_ERROR, DURACION_BEEP_MS);
    delay(DURACION_BEEP_MS);
    noTone(PIN_BUZZER);
    delay(PAUSA_BEEP_MS);
  }
}

// Compara lo tecleado con la clave guardada.
bool claveCorrecta() {
  for (byte i = 0; i < LARGO_CLAVE; i++) {
    if (tecleado[i] != clave[i]) {
      return false;
    }
  }
  return true;
}

void setup() {
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);
  pinMode(PIN_BUZZER, OUTPUT);

  cerradura.attach(PIN_SERVO);
  // Arranca CERRADA (LED rojo).
  puertaAbierta = false;
  cerradura.write(ANGULO_CERRADA);
  mostrarEstadoEnLeds();
}

void loop() {
  char tecla = teclado.getKey();
  if (!tecla) {
    return;  // no se presiono ninguna tecla en esta vuelta
  }

  tecleado[indice] = tecla;
  indice++;

  if (indice == LARGO_CLAVE) {
    indice = 0;

    if (claveCorrecta()) {
      beepCorrecta();
      puertaAbierta = !puertaAbierta;
      cerradura.write(puertaAbierta ? ANGULO_ABIERTA : ANGULO_CERRADA);
      mostrarEstadoEnLeds();
    } else {
      beepIncorrecta();  // no toca la cerradura
    }
  }
}

// Cerradura automatizada — Nivel Avanzado (Arduino UNO), NO BLOQUEANTE.
//
// Misma cerradura por teclado del nivel intermedio, pero SIN delay(): los
// pitidos del buzzer se manejan con una pequena maquina de estados basada en
// millis(). Asi loop() nunca se detiene y el sistema queda listo para tareas
// concurrentes (como el monitoreo IoT). El teclado 4x4 lee la clave, la
// cerradura conmuta con clave correcta y los LED indican el estado
// (verde = abierta, rojo = cerrada).
//
// Clave del original: '1' '5' '9' 'D'.
//
// >>> IoT EN UNO: CONCEPTUAL <<<
// El nivel avanzado del original agrega IoT, pero su implementacion en UNO es
// IRREALIZABLE: usa el modulo OBLOQ sobre SoftwareSerial cableado a los pines
// 0/1 en el codigo (que son el USB/serial de programacion: lo rompe) y a los
// pines 8/9 en el texto (que CHOCAN con dos filas del teclado 4x4). Ademas el
// OBLOQ y su libreria ObloqAdafruit estan discontinuados. Por eso, en UNO el
// IoT queda como EXPLICACION CONCEPTUAL y la practica se hace con el ESP32
// (WiFi nativo), en esp32/nivel-avanzado/cerradura-iot.ino. Este sketch de UNO
// deja el sistema NO BLOQUEANTE justamente como base sobre la que el IoT
// podria montarse — la misma progresion didactica que ensena el original.
//
// Plataforma: Arduino UNO. Proyecto de BAJA TENSION: sin 220 V ni agua.
//
// Basado en: Fragmentos de codigo de los Niveles Intermedio y Avanzado —
// Cerradura Automatica, Saberes Digitales (INET/EDUCAR 2019).
// Desvios (ver README): pines unificados; buzzer con tone(); pitidos NO
// bloqueantes con millis(); IoT conceptual (se resuelve en ESP32).

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

// --- Pines (esquema UNIFICADO del contrato) ---
const int PIN_SERVO     = 10;
const int PIN_LED_VERDE = 11;  // encendido = ABIERTA
const int PIN_BUZZER    = 12;
const int PIN_LED_ROJO  = 13;  // encendido = CERRADA

// Angulos del servo (unificados en los tres niveles).
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// --- Teclado matricial 4x4 ---
const byte FILAS    = 4;
const byte COLUMNAS = 4;
char teclas[FILAS][COLUMNAS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte pinesFilas[FILAS]       = {9, 8, 7, 6};
byte pinesColumnas[COLUMNAS] = {5, 4, 3, 2};
Keypad teclado = Keypad(makeKeymap(teclas), pinesFilas, pinesColumnas,
                        FILAS, COLUMNAS);

// --- Clave (la del original) y buffer de lo tecleado ---
const byte LARGO_CLAVE = 4;
char clave[LARGO_CLAVE]    = {'1', '5', '9', 'D'};
char tecleado[LARGO_CLAVE] = {0, 0, 0, 0};
byte indice = 0;

// --- Buzzer NO bloqueante ---
// tone(pin, freq, duracion) ya suena sin bloquear (lo maneja un timer). Para
// encadenar varios pitidos con pausas, programamos cada uno con millis() en
// vez de usar delay().
const unsigned int FREQ_OK    = 1000;  // Hz, agudo = correcta
const unsigned int FREQ_ERROR = 400;   // Hz, grave = incorrecta
const unsigned long DURACION_BEEP_MS = 200;
const unsigned long PERIODO_BEEP_MS  = 500;  // 200 ms de tono + 300 ms de pausa

byte          beepsPendientes = 0;   // cuantos pitidos quedan por emitir
unsigned int  freqBeep        = 0;   // frecuencia del pitido en curso
unsigned long proximoBeepMs   = 0;   // cuando disparar el proximo pitido

// Estado de la puerta: true = abierta, false = cerrada.
bool puertaAbierta = false;

Servo cerradura;

void mostrarEstadoEnLeds() {
  digitalWrite(PIN_LED_VERDE, puertaAbierta ? HIGH : LOW);
  digitalWrite(PIN_LED_ROJO, puertaAbierta ? LOW : HIGH);
}

// Programa una serie de pitidos (los emite actualizarBuzzer sin bloquear).
void programarBeeps(byte cantidad, unsigned int frecuencia) {
  beepsPendientes = cantidad;
  freqBeep        = frecuencia;
  proximoBeepMs   = millis();  // el primero suena ya
}

// Debe llamarse en cada vuelta de loop(): dispara el proximo pitido cuando
// corresponde, sin detener el programa.
void actualizarBuzzer() {
  if (beepsPendientes == 0) {
    return;
  }
  if (millis() >= proximoBeepMs) {
    tone(PIN_BUZZER, freqBeep, DURACION_BEEP_MS);  // no bloqueante
    beepsPendientes--;
    proximoBeepMs = millis() + PERIODO_BEEP_MS;
  }
}

bool claveCorrecta() {
  for (byte i = 0; i < LARGO_CLAVE; i++) {
    if (tecleado[i] != clave[i]) {
      return false;
    }
  }
  return true;
}

void setup() {
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);
  pinMode(PIN_BUZZER, OUTPUT);

  cerradura.attach(PIN_SERVO);
  puertaAbierta = false;  // arranca CERRADA (LED rojo)
  cerradura.write(ANGULO_CERRADA);
  mostrarEstadoEnLeds();
}

void loop() {
  // 1) Atender el teclado (no bloquea: getKey devuelve 0 si no hay tecla).
  char tecla = teclado.getKey();
  if (tecla) {
    tecleado[indice] = tecla;
    indice++;

    if (indice == LARGO_CLAVE) {
      indice = 0;

      if (claveCorrecta()) {
        programarBeeps(1, FREQ_OK);          // un pitido de OK
        puertaAbierta = !puertaAbierta;      // conmuta la cerradura
        cerradura.write(puertaAbierta ? ANGULO_ABIERTA : ANGULO_CERRADA);
        mostrarEstadoEnLeds();
      } else {
        programarBeeps(2, FREQ_ERROR);       // doble pitido de error
      }
    }
  }

  // 2) Atender el buzzer sin bloquear.
  actualizarBuzzer();

  // 3) (Aca iria el mantenimiento IoT: en UNO es conceptual — ver ESP32.)
}

// Cerradura automatizada — Nivel Avanzado (ESP32 DevKit v1), NO BLOQUEANTE.
//
// Misma cerradura por teclado del nivel intermedio, pero SIN delay(): los
// pitidos del buzzer se manejan con una pequena maquina de estados basada en
// millis(). Asi loop() nunca se detiene y el sistema queda listo para sumar el
// monitoreo IoT (ver cerradura-iot.ino en esta misma carpeta). El teclado 4x4
// lee la clave, la cerradura conmuta con clave correcta y los LED indican el
// estado (verde = abierta, rojo = cerrada).
//
// Clave del original: '1' '5' '9' 'D'.
//
// Este sketch es el paso previo al IoT: deja toda la logica NO bloqueante para
// que agregar WiFi + MQTT (cerradura-iot.ino) no desatienda el teclado.
//
// Plataforma: ESP32 (DevKit v1). Servo con ESP32Servo; buzzer con tone().
// Nota electrica: 3,3 V (alimentar el servo desde 5 V con GND comun).
// Proyecto de BAJA TENSION: sin 220 V ni agua.
//
// Basado en: Fragmentos de codigo de los Niveles Intermedio y Avanzado —
// Cerradura Automatica, Saberes Digitales (INET/EDUCAR 2019).
// Desvios (ver README): pines GPIO seguros del contrato; buzzer con tone();
// pitidos NO bloqueantes con millis().

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

// --- Pines (GPIO seguros del contrato) ---
const int PIN_SERVO     = 13;
const int PIN_LED_VERDE = 25;  // encendido = ABIERTA
const int PIN_LED_ROJO  = 26;  // encendido = CERRADA
const int PIN_BUZZER    = 14;

// Angulos del servo (unificados en los tres niveles).
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// --- Teclado matricial 4x4 ---
const byte FILAS    = 4;
const byte COLUMNAS = 4;
char teclas[FILAS][COLUMNAS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte pinesFilas[FILAS]       = {16, 17, 18, 19};
byte pinesColumnas[COLUMNAS] = {21, 22, 23, 27};
Keypad teclado = Keypad(makeKeymap(teclas), pinesFilas, pinesColumnas,
                        FILAS, COLUMNAS);

// --- Clave (la del original) y buffer de lo tecleado ---
const byte LARGO_CLAVE = 4;
char clave[LARGO_CLAVE]    = {'1', '5', '9', 'D'};
char tecleado[LARGO_CLAVE] = {0, 0, 0, 0};
byte indice = 0;

// --- Buzzer NO bloqueante ---
const unsigned int FREQ_OK    = 1000;  // Hz, agudo = correcta
const unsigned int FREQ_ERROR = 400;   // Hz, grave = incorrecta
const unsigned long DURACION_BEEP_MS = 200;
const unsigned long PERIODO_BEEP_MS  = 500;  // 200 ms de tono + 300 ms de pausa

byte          beepsPendientes = 0;
unsigned int  freqBeep        = 0;
unsigned long proximoBeepMs   = 0;

// Estado de la puerta: true = abierta, false = cerrada.
bool puertaAbierta = false;

Servo cerradura;

void mostrarEstadoEnLeds() {
  digitalWrite(PIN_LED_VERDE, puertaAbierta ? HIGH : LOW);
  digitalWrite(PIN_LED_ROJO, puertaAbierta ? LOW : HIGH);
}

void programarBeeps(byte cantidad, unsigned int frecuencia) {
  beepsPendientes = cantidad;
  freqBeep        = frecuencia;
  proximoBeepMs   = millis();
}

void actualizarBuzzer() {
  if (beepsPendientes == 0) {
    return;
  }
  if (millis() >= proximoBeepMs) {
    tone(PIN_BUZZER, freqBeep, DURACION_BEEP_MS);  // no bloqueante
    beepsPendientes--;
    proximoBeepMs = millis() + PERIODO_BEEP_MS;
  }
}

bool claveCorrecta() {
  for (byte i = 0; i < LARGO_CLAVE; i++) {
    if (tecleado[i] != clave[i]) {
      return false;
    }
  }
  return true;
}

void setup() {
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);
  pinMode(PIN_BUZZER, OUTPUT);

  cerradura.attach(PIN_SERVO);
  puertaAbierta = false;  // arranca CERRADA (LED rojo)
  cerradura.write(ANGULO_CERRADA);
  mostrarEstadoEnLeds();
}

void loop() {
  char tecla = teclado.getKey();
  if (tecla) {
    tecleado[indice] = tecla;
    indice++;

    if (indice == LARGO_CLAVE) {
      indice = 0;

      if (claveCorrecta()) {
        programarBeeps(1, FREQ_OK);
        puertaAbierta = !puertaAbierta;
        cerradura.write(puertaAbierta ? ANGULO_ABIERTA : ANGULO_CERRADA);
        mostrarEstadoEnLeds();
      } else {
        programarBeeps(2, FREQ_ERROR);
      }
    }
  }

  actualizarBuzzer();
}

// Cerradura automatizada — Nivel Avanzado + IoT (ESP32 DevKit v1).
//
// Toma la cerradura por teclado NO bloqueante (cerradura-no-bloqueante.ino) y
// le suma monitoreo remoto: cada vez que la puerta CAMBIA de estado, publica
// en el feed "cerradura" de Adafruit IO:
//
//   1 = ABIERTA   0 = CERRADA
//
// Asi el abuelo puede ver desde el celular si la puerta se abrio o cerro, tal
// como plantea la situacion-problema del nivel avanzado. La publicacion es
// EVENT-DRIVEN: solo se publica en el momento del cambio (no en cada vuelta),
// por lo que se respeta de sobra el cupo gratuito de Adafruit IO (30/min).
//
// Clave del original: '1' '5' '9' 'D'.
//
// Plataforma: ESP32 (DevKit v1) — WiFi integrado. Servo con ESP32Servo; buzzer
// con tone(). Nota electrica: 3,3 V (alimentar el servo desde 5 V, GND comun).
// Proyecto de BAJA TENSION: sin 220 V ni agua.
//
// Basado en: Fragmento de codigo del Nivel Avanzado (Paso 6, publicacion del
// estado de la cerradura) — Cerradura Automatica, Saberes Digitales
// (INET/EDUCAR 2019).
// Desvios / modernizaciones (ver README):
//  (1) OBLOQ IRREALIZABLE EN EL ORIGINAL: usaba SoftwareSerial(0,1) — que son
//      el USB/serial de programacion del UNO (lo rompe) — y el texto lo cableaba
//      a (8,9), que CHOCAN con dos filas del teclado 4x4. El OBLOQ y su libreria
//      ObloqAdafruit ademas estan discontinuados. Se reemplaza por el WiFi
//      NATIVO del ESP32 + MQTT contra io.adafruit.com (libreria "Adafruit MQTT
//      Library"). El IoT de este proyecto solo es realizable en ESP32.
//  (2) Publicacion EVENT-DRIVEN (solo al cambiar el estado), no en cada vuelta.
//  (3) Reconexion MQTT NO bloqueante (reintento cada 5 s), sin frenar teclado
//      ni buzzer.
//  (4) Pines GPIO seguros del contrato; buzzer con tone(); pitidos NO
//      bloqueantes con millis().

#include <WiFi.h>
#include <Keypad.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"

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

// --- Pines (GPIO seguros del contrato) ---
const int PIN_SERVO     = 13;
const int PIN_LED_VERDE = 25;  // encendido = ABIERTA
const int PIN_LED_ROJO  = 26;  // encendido = CERRADA
const int PIN_BUZZER    = 14;

// Angulos del servo (unificados en los tres niveles).
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// --- Teclado matricial 4x4 ---
const byte FILAS    = 4;
const byte COLUMNAS = 4;
char teclas[FILAS][COLUMNAS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte pinesFilas[FILAS]       = {16, 17, 18, 19};
byte pinesColumnas[COLUMNAS] = {21, 22, 23, 27};
Keypad teclado = Keypad(makeKeymap(teclas), pinesFilas, pinesColumnas,
                        FILAS, COLUMNAS);

// --- Clave (la del original) y buffer de lo tecleado ---
const byte LARGO_CLAVE = 4;
char clave[LARGO_CLAVE]    = {'1', '5', '9', 'D'};
char tecleado[LARGO_CLAVE] = {0, 0, 0, 0};
byte indice = 0;

// --- Buzzer NO bloqueante ---
const unsigned int FREQ_OK    = 1000;  // Hz, agudo = correcta
const unsigned int FREQ_ERROR = 400;   // Hz, grave = incorrecta
const unsigned long DURACION_BEEP_MS = 200;
const unsigned long PERIODO_BEEP_MS  = 500;

byte          beepsPendientes = 0;
unsigned int  freqBeep        = 0;
unsigned long proximoBeepMs   = 0;

// Estado de la puerta: true = abierta, false = cerrada.
bool puertaAbierta = false;

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

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

// Ultimo valor publicado con exito (-1 fuerza la primera publicacion).
int cerraduraPublicada = -1;

Servo cerradura;

void mostrarEstadoEnLeds() {
  digitalWrite(PIN_LED_VERDE, puertaAbierta ? HIGH : LOW);
  digitalWrite(PIN_LED_ROJO, puertaAbierta ? LOW : HIGH);
}

void programarBeeps(byte cantidad, unsigned int frecuencia) {
  beepsPendientes = cantidad;
  freqBeep        = frecuencia;
  proximoBeepMs   = millis();
}

void actualizarBuzzer() {
  if (beepsPendientes == 0) {
    return;
  }
  if (millis() >= proximoBeepMs) {
    tone(PIN_BUZZER, freqBeep, DURACION_BEEP_MS);  // no bloqueante
    beepsPendientes--;
    proximoBeepMs = millis() + PERIODO_BEEP_MS;
  }
}

bool claveCorrecta() {
  for (byte i = 0; i < LARGO_CLAVE; i++) {
    if (tecleado[i] != clave[i]) {
      return false;
    }
  }
  return true;
}

// Mantiene viva la conexion MQTT sin bloquear: si esta caida, reintenta como
// mucho una vez cada 5 s (mismo patron que el resto de la coleccion).
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 el estado SOLO cuando cambia (event-driven). Si no hay conexion o el
// publish falla, no se actualiza el registro: se reintenta en el proximo cambio
// o cuando vuelva la conexion.
void publicarEstadoSiCambio() {
  int valor = puertaAbierta ? 1 : 0;
  if (valor == cerraduraPublicada) {
    return;  // sin cambios: nada que publicar
  }
  if (!mqtt.connected()) {
    return;  // sin internet: se publicara cuando reconecte
  }
  if (feedCerradura.publish((int32_t) valor)) {
    cerraduraPublicada = valor;
  }
}

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

  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);
  pinMode(PIN_BUZZER, OUTPUT);

  cerradura.attach(PIN_SERVO);
  puertaAbierta = false;  // arranca CERRADA (LED rojo)
  cerradura.write(ANGULO_CERRADA);
  mostrarEstadoEnLeds();

  // Conexion WiFi. Bloquear aca con delay() es aceptable: el ciclo de teclado
  // 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) Teclado (no bloquea).
  char tecla = teclado.getKey();
  if (tecla) {
    tecleado[indice] = tecla;
    indice++;

    if (indice == LARGO_CLAVE) {
      indice = 0;

      if (claveCorrecta()) {
        programarBeeps(1, FREQ_OK);
        puertaAbierta = !puertaAbierta;
        cerradura.write(puertaAbierta ? ANGULO_ABIERTA : ANGULO_CERRADA);
        mostrarEstadoEnLeds();
        publicarEstadoSiCambio();  // publica el cambio al instante
      } else {
        programarBeeps(2, FREQ_ERROR);
      }
    }
  }

  // 2) Buzzer no bloqueante.
  actualizarBuzzer();

  // 3) Mantenimiento IoT en cada vuelta. Si el publish previo fallo por estar
  //    sin conexion, al reconectar se reintenta el estado actual.
  mantenerConexionMqtt();
  publicarEstadoSiCambio();
}