Sistema Lumínico

// 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);
  }
}

// Lectura de la fotorresistencia (LDR) por consola serial.
// A diferencia del PIR (que solo dice 1 o 0), el LDR es un sensor
// ANALÓGICO: en el UNO, analogRead() devuelve un valor entre 0 (0 V,
// oscuridad total en nuestro divisor) y 1023 (5 V, mucha luz).
// Medir en distintos momentos del día y anotar los valores es lo que
// después permite elegir un umbral con fundamento, no a ojo.
//
// Plataforma: Arduino UNO.
// Conexión: divisor resistivo LDR + resistencia de 10 kohm; el punto
// medio del divisor → pin A0. Con este cableado, más luz = valor más alto.
// Consola: Monitor Serie del IDE de Arduino a 9600 baudios.
//
// Basado en: código del Paso 2, Nivel Avanzado — Automatización de Sistema
// Lumínico, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: se reemplazaron los bloques de mBlock3 por Serial.println()
// con una pausa entre lecturas para que la consola sea legible.

const int PIN_LDR = A0;

const long VELOCIDAD_SERIAL = 9600;

// Dos lecturas por segundo: suficiente para ver cómo cambia la luz
// ambiente sin inundar la consola.
const unsigned long INTERVALO_LECTURA_MS = 500;

void setup() {
  pinMode(PIN_LDR, INPUT);
  Serial.begin(VELOCIDAD_SERIAL);
}

void loop() {
  // Tapá el sensor con la mano, iluminalo con una linterna, y observá
  // el rango real de valores de TU aula: ese experimento es el que
  // define el umbral del paso siguiente (luz-nocturna.ino).
  Serial.println(analogRead(PIN_LDR));
  delay(INTERVALO_LECTURA_MS);
}

// Lectura de la fotorresistencia (LDR) por consola serial.
// A diferencia del PIR (que solo dice 1 o 0), el LDR es un sensor
// ANALÓGICO. OJO con esta diferencia didáctica: el conversor del ESP32
// es de 12 bits, así que analogRead() devuelve valores entre 0 (0 V) y
// 4095 (3,3 V), NO el 0-1023 (10 bits) del Arduino UNO. Mismo fenómeno
// físico, distinta "regla de medir": por eso los umbrales de un programa
// no se copian entre placas sin pensar.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: divisor resistivo LDR + resistencia de 10 kohm alimentado con
// 3,3 V; el punto medio del divisor → GPIO 34. Con este cableado, más luz
// = valor más alto.
// IMPORTANTE: el GPIO 34 es de SOLO ENTRADA y no tiene resistencias
// internas de pull-up/pull-down, por lo que el divisor resistivo externo
// es OBLIGATORIO: sin él, el pin queda "flotando" y lee cualquier cosa.
// (Es un GPIO del ADC1, que sigue funcionando aunque se use WiFi; los
// pines del ADC2 dejan de medir con WiFi activo.)
// Consola: Monitor Serie del IDE de Arduino a 9600 baudios.
//
// Basado en: código del Paso 2, Nivel Avanzado — Automatización de Sistema
// Lumínico, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: portado a ESP32 (LDR en GPIO 34; el original usaba A0 del
// UNO) y Serial.println() con pausa entre lecturas en lugar de los bloques
// de mBlock3.

const int PIN_LDR = 34;

const long VELOCIDAD_SERIAL = 9600;

// Dos lecturas por segundo: suficiente para ver cómo cambia la luz
// ambiente sin inundar la consola.
const unsigned long INTERVALO_LECTURA_MS = 500;

void setup() {
  pinMode(PIN_LDR, INPUT);
  Serial.begin(VELOCIDAD_SERIAL);
}

void loop() {
  // Tapá el sensor con la mano, iluminalo con una linterna, y observá
  // el rango real de valores de TU aula (acá entre 0 y 4095): ese
  // experimento es el que define el umbral del paso siguiente
  // (luz-nocturna.ino).
  Serial.println(analogRead(PIN_LDR));
  delay(INTERVALO_LECTURA_MS);
}

// Luz nocturna: el relé enciende la lámpara cuando el nivel de luz
// exterior es bajo, y la apaga cuando es alto.
// Lógica exacta del original: si la lectura del LDR es MENOR que el
// umbral, enciende; si no, apaga. El código de este paso usa SOLO el
// LDR (la combinación con el PIR queda como extensión propuesta por
// la prosa de la guía, no como código del original).
//
// 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: divisor resistivo del LDR → pin A0 (más luz = valor más alto);
//           entrada IN del módulo relé → pin 7.
//
// Basado en: código del Paso 3, Nivel Avanzado — Automatización de Sistema
// Lumínico, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas en lugar del C generado por mBlock3;
// el relé se mueve del pin 2 (original) al pin 7 (contrato de pines de la
// reedición).

const int PIN_LDR  = A0;
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;

// Umbral del original: 600 sobre un rango de 0 a 1023 (10 bits del UNO).
// No es un número mágico: sale de haber MEDIDO la luz del lugar con
// lectura-ldr.ino. Si tus mediciones dieron otro rango, ajustalo acá.
const int UMBRAL_LUZ = 600;

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

void loop() {
  // Menos luz que el umbral → está oscureciendo → encender la lámpara.
  if (analogRead(PIN_LDR) < UMBRAL_LUZ) {
    digitalWrite(PIN_RELE, RELE_ENCENDIDO);
  } else {
    digitalWrite(PIN_RELE, RELE_APAGADO);
  }
  // Sin delay(): este programa ya es naturalmente no bloqueante, igual
  // que el original. El relé solo conmuta cuando la condición cambia.
}

// Luz nocturna: el relé enciende la lámpara cuando el nivel de luz
// exterior es bajo, y la apaga cuando es alto.
// Lógica exacta del original: si la lectura del LDR es MENOR que el
// umbral, enciende; si no, apaga. El código de este paso usa SOLO el
// LDR (la combinación con el PIR queda como extensión propuesta por
// la prosa de la guía, no como código del original).
//
// 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: divisor resistivo del LDR (obligatorio: el GPIO 34 es de solo
// entrada y no tiene pull-up interno) → GPIO 34, con más luz = valor más
// alto; 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 3, Nivel Avanzado — Automatización de Sistema
// Lumínico, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas en lugar del C generado por mBlock3;
// portado a ESP32 (el original usaba A0 y relé en pin 2 del UNO) y umbral
// reescalado al ADC de 12 bits del ESP32.

const int PIN_LDR  = 34;
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;

// El original usa 600 sobre el rango 0-1023 del UNO (ADC de 10 bits).
// El ADC del ESP32 es de 12 bits (0-4095): para que el umbral represente
// el MISMO nivel de luz hay que reescalarlo en la misma proporción:
// 600/1023 ≈ 2400/4095. Mismo fenómeno, distinta resolución: por eso los
// umbrales nunca se copian entre placas sin ajustar. Y como siempre,
// el valor definitivo sale de medir con lectura-ldr.ino en tu lugar.
const int UMBRAL_LUZ = 2400;

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

void loop() {
  // Menos luz que el umbral → está oscureciendo → encender la lámpara.
  if (analogRead(PIN_LDR) < UMBRAL_LUZ) {
    digitalWrite(PIN_RELE, RELE_ENCENDIDO);
  } else {
    digitalWrite(PIN_RELE, RELE_APAGADO);
  }
  // Sin delay(): este programa ya es naturalmente no bloqueante, igual
  // que el original. El relé solo conmuta cuando la condición cambia.
}