Luces automáticas con sensor de movimiento

// Encendido y apagado temporizado de las luces a través de un módulo relé.
// Prueba intermitente (1 s encendido / 1 s apagado) para verificar que el
// relé y la lámpara responden antes de agregar sensores.
//
// SEGURIDAD: esta práctica se realiza con una lámpara LED de baja tensión.
// La conexión a 220 V queda reservada al docente o a una instalación
// supervisada, y NUNCA sobre la protoboard (desvío pedagógico acordado
// sobre la advertencia de 220 V de la guía original).
//
// Plataforma: Arduino UNO.
// Conexión: entrada IN del módulo relé → pin 7 (VCC a 5 V, GND a GND).
//
// Basado en: código del Paso 2, Nivel Inicial — Automatización de Sistema
// Lumínico, 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 el relé se mueve
// del pin 2 (original) al pin 7 (contrato de pines de la reedición).

const int PIN_RELE = 7;

// El original explica: estado ALTO = pasa corriente = lámpara encendida.
// Ese es un módulo relé "activo-alto". Muchos módulos escolares baratos
// son "activo-bajo" (se activan con LOW): si el tuyo enciende al revés,
// invertí SOLO estas dos constantes y el resto del programa queda igual.
// Esa es la gracia de las constantes con nombre.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

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

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

void loop() {
  // delay() detiene todo el programa: para esta prueba de encendido es
  // perfecto, porque el código se lee igual que la secuencia real.
  digitalWrite(PIN_RELE, RELE_ENCENDIDO); // la lámpara enciende
  delay(DURACION_ENCENDIDO_MS);
  digitalWrite(PIN_RELE, RELE_APAGADO);   // la lámpara se apaga
  delay(DURACION_APAGADO_MS);
}

// Encendido y apagado temporizado de las luces a través de un módulo relé.
// Prueba intermitente (1 s encendido / 1 s apagado) para verificar que el
// relé y la lámpara responden antes de agregar sensores.
//
// SEGURIDAD: esta práctica se realiza con una lámpara LED de baja tensión.
// La conexión a 220 V queda reservada al docente o a una instalación
// supervisada, y NUNCA sobre la protoboard (desvío pedagógico acordado
// sobre la advertencia de 220 V de la guía original).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: entrada IN del módulo relé → GPIO 16.
// Nota eléctrica: el ESP32 trabaja a 3,3 V (no 5 V como el UNO). Elegí un
// módulo relé cuya entrada acepte señal de 3,3 V (la mayoría de los módulos
// escolares la aceptan aunque se alimenten con 5 V) y nunca inyectes 5 V
// en un GPIO del ESP32.
//
// Basado en: código del Paso 2, Nivel Inicial — Automatización de Sistema
// Lumínico, 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, relé en pin 2) a ESP32 con GPIO seguros.

const int PIN_RELE = 16;

// El original explica: estado ALTO = pasa corriente = lámpara encendida.
// Ese es un módulo relé "activo-alto". Muchos módulos escolares baratos
// son "activo-bajo" (se activan con LOW): si el tuyo enciende al revés,
// invertí SOLO estas dos constantes y el resto del programa queda igual.
// Esa es la gracia de las constantes con nombre.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

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

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

void loop() {
  // delay() detiene todo el programa: para esta prueba de encendido es
  // perfecto, porque el código se lee igual que la secuencia real.
  digitalWrite(PIN_RELE, RELE_ENCENDIDO); // la lámpara enciende
  delay(DURACION_ENCENDIDO_MS);
  digitalWrite(PIN_RELE, RELE_APAGADO);   // la lámpara se apaga
  delay(DURACION_APAGADO_MS);
}

// Lectura y calibración del sensor de movimiento (PIR) por consola serial.
// El PIR devuelve 1 cuando detecta movimiento y 0 cuando no. Ver esos
// valores en la consola permite calibrar los dos trimmers del módulo
// (sensibilidad y tiempo de retención) ANTES de conectar el relé:
// primero entendemos al sensor, después automatizamos con él.
//
// Plataforma: Arduino UNO.
// Conexión: salida de datos del PIR → pin 4 (VCC a 5 V, GND a GND).
// Consola: Monitor Serie del IDE de Arduino a 9600 baudios.
//
// Basado en: código de los Pasos 5 y 6, Nivel Inicial — Automatización de
// Sistema Lumínico, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: el original enviaba a la consola con bloques de mBlock3
// ("Escribir en el serial" dentro de "Por siempre", sin pausa); acá se usa
// Serial.println() con una pequeña pausa entre lecturas para que la
// consola sea legible y no se inunde de números.

const int PIN_PIR = 4;

const long VELOCIDAD_SERIAL = 9600;

// Sin esta pausa el UNO imprimiría miles de lecturas por segundo y la
// consola sería ilegible. Cinco lecturas por segundo alcanzan de sobra
// para ver cuándo el PIR pasa de 0 a 1.
const unsigned long INTERVALO_LECTURA_MS = 200;

void setup() {
  pinMode(PIN_PIR, INPUT);
  // Abre la comunicación con la computadora. El número debe coincidir
  // con el que se elige en el Monitor Serie: es la "velocidad" a la que
  // ambos acuerdan hablar.
  Serial.begin(VELOCIDAD_SERIAL);
}

void loop() {
  // digitalRead devuelve 1 (movimiento) o 0 (sin movimiento): con eso
  // a la vista, ajustá los trimmers del PIR hasta que las detecciones
  // se correspondan con lo que pasa en el ambiente.
  Serial.println(digitalRead(PIN_PIR));
  delay(INTERVALO_LECTURA_MS);
}

// Lectura y calibración del sensor de movimiento (PIR) por consola serial.
// El PIR devuelve 1 cuando detecta movimiento y 0 cuando no. Ver esos
// valores en la consola permite calibrar los dos trimmers del módulo
// (sensibilidad y tiempo de retención) ANTES de conectar el relé:
// primero entendemos al sensor, después automatizamos con él.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: salida de datos del PIR → GPIO 27.
// Nota eléctrica: el ESP32 trabaja a 3,3 V. Los PIR tipo HC-SR501 suelen
// alimentarse con 5 V pero su salida de datos es de 3,3 V, así que puede
// ir directo al GPIO; verificá la hoja de datos de tu módulo.
// Consola: Monitor Serie del IDE de Arduino a 9600 baudios.
//
// Basado en: código de los Pasos 5 y 6, Nivel Inicial — Automatización de
// Sistema Lumínico, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: el original enviaba a la consola con bloques de mBlock3
// (PIR en pin 4 del UNO, sin pausa); acá se porta a ESP32 (GPIO 27) y se
// usa Serial.println() con una pequeña pausa entre lecturas para que la
// consola sea legible y no se inunde de números.

const int PIN_PIR = 27;

const long VELOCIDAD_SERIAL = 9600;

// Sin esta pausa el ESP32 imprimiría miles de lecturas por segundo y la
// consola sería ilegible. Cinco lecturas por segundo alcanzan de sobra
// para ver cuándo el PIR pasa de 0 a 1.
const unsigned long INTERVALO_LECTURA_MS = 200;

void setup() {
  pinMode(PIN_PIR, INPUT);
  // Abre la comunicación con la computadora. El número debe coincidir
  // con el que se elige en el Monitor Serie: es la "velocidad" a la que
  // ambos acuerdan hablar.
  Serial.begin(VELOCIDAD_SERIAL);
}

void loop() {
  // digitalRead devuelve 1 (movimiento) o 0 (sin movimiento): con eso
  // a la vista, ajustá los trimmers del PIR hasta que las detecciones
  // se correspondan con lo que pasa en el ambiente.
  Serial.println(digitalRead(PIN_PIR));
  delay(INTERVALO_LECTURA_MS);
}

// Luz automática por movimiento: el relé enciende la lámpara cuando el
// sensor PIR detecta a alguien, y la mantiene encendida un "tiempo de
// cortesía" antes de volver a evaluar. Si no hay movimiento, la apaga.
//
// El tiempo de cortesía cumple dos funciones (así lo plantea el original):
// evita que el sistema esté revisando el sensor sin parar, y garantiza que
// la luz no se apague apenas la persona se queda quieta.
//
// SEGURIDAD: esta práctica se realiza con una lámpara LED de baja tensión.
// La conexión a 220 V queda reservada al docente o a una instalación
// supervisada, y NUNCA sobre la protoboard (desvío pedagógico acordado
// sobre la advertencia de 220 V de la guía original).
//
// Plataforma: Arduino UNO.
// Conexión: PIR → pin 4; entrada IN del módulo relé → pin 7.
//
// Basado en: código del Paso 8, Nivel Inicial — Automatización de Sistema
// Lumínico, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas en lugar del C generado por mBlock3
// (_delay, _loop); el relé se mueve del pin 2 (original) al pin 7
// (contrato de pines de la reedición). Se mantiene el delay() bloqueante
// del original: en este nivel es la herramienta que ya conocemos.

const int PIN_PIR  = 4;
const int PIN_RELE = 7;

// Módulo relé activo-alto, como lo explica el original (HIGH = enciende).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

// 10 minutos, como propone la guía original (600 segundos).
// Para probar en el aula conviene bajarlo temporalmente (por ejemplo a
// 10000, es decir 10 segundos): nadie quiere esperar 10 minutos para
// ver si el programa funciona.
const unsigned long TIEMPO_CORTESIA_MS = 600000;

void setup() {
  pinMode(PIN_PIR, INPUT);
  pinMode(PIN_RELE, OUTPUT);
}

void loop() {
  // El PIR devuelve HIGH (1) cuando detecta movimiento.
  if (digitalRead(PIN_PIR) == HIGH) {
    digitalWrite(PIN_RELE, RELE_ENCENDIDO);
    // Durante este delay() el programa queda detenido con la luz
    // encendida: ese es exactamente el tiempo de cortesía. Recién al
    // terminar vuelve a preguntar si hay movimiento.
    delay(TIEMPO_CORTESIA_MS);
  } else {
    // Sin movimiento: la lámpara se apaga y loop() vuelve a empezar,
    // consultando el sensor de forma continua.
    digitalWrite(PIN_RELE, RELE_APAGADO);
  }
}

// Luz automática por movimiento: el relé enciende la lámpara cuando el
// sensor PIR detecta a alguien, y la mantiene encendida un "tiempo de
// cortesía" antes de volver a evaluar. Si no hay movimiento, la apaga.
//
// El tiempo de cortesía cumple dos funciones (así lo plantea el original):
// evita que el sistema esté revisando el sensor sin parar, y garantiza que
// la luz no se apague apenas la persona se queda quieta.
//
// SEGURIDAD: esta práctica se realiza con una lámpara LED de baja tensión.
// La conexión a 220 V queda reservada al docente o a una instalación
// supervisada, y NUNCA sobre la protoboard (desvío pedagógico acordado
// sobre la advertencia de 220 V de la guía original).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: PIR → GPIO 27; entrada IN del módulo relé → GPIO 16.
// 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: código del Paso 8, Nivel Inicial — Automatización de Sistema
// Lumínico, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas en lugar del C generado por mBlock3
// (_delay, _loop); portado a ESP32 con GPIO seguros (el original usaba
// PIR en pin 4 y relé en pin 2 del UNO). Se mantiene el delay() bloqueante
// del original: en este nivel es la herramienta que ya conocemos.

const int PIN_PIR  = 27;
const int PIN_RELE = 16;

// Módulo relé activo-alto, como lo explica el original (HIGH = enciende).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

// 10 minutos, como propone la guía original (600 segundos).
// Para probar en el aula conviene bajarlo temporalmente (por ejemplo a
// 10000, es decir 10 segundos): nadie quiere esperar 10 minutos para
// ver si el programa funciona.
const unsigned long TIEMPO_CORTESIA_MS = 600000;

void setup() {
  pinMode(PIN_PIR, INPUT);
  pinMode(PIN_RELE, OUTPUT);
}

void loop() {
  // El PIR devuelve HIGH (1) cuando detecta movimiento.
  if (digitalRead(PIN_PIR) == HIGH) {
    digitalWrite(PIN_RELE, RELE_ENCENDIDO);
    // Durante este delay() el programa queda detenido con la luz
    // encendida: ese es exactamente el tiempo de cortesía. Recién al
    // terminar vuelve a preguntar si hay movimiento.
    delay(TIEMPO_CORTESIA_MS);
  } else {
    // Sin movimiento: la lámpara se apaga y loop() vuelve a empezar,
    // consultando el sensor de forma continua.
    digitalWrite(PIN_RELE, RELE_APAGADO);
  }
}