Luz según la luz: el sensor LDR

// 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.
}