← Volver a proyectos
PROYECTO #03 Iniciación ⏱ 40 min

Luz Nocturna
Automática

El LED se enciende solo cuando detecta poca luz. Tu primera automatización real: un sistema que toma decisiones sin que intervengas — igual que las farolas de la calle.

Sensor Luz (LDR) LED Verde micro:bit 🔌 2 pines 📚 Señal analógica
💡 Concepto clave — Señal analógica vs digital
En los proyectos anteriores usabas señales digitales: solo 0 o 1 (encendido/apagado). El sensor de luz es analógico: devuelve un número entre 0 y 1023 que representa la cantidad de luz. Cuanta más luz, mayor el número. Con ese valor podemos tomar decisiones más inteligentes.
0
Oscuridad total
~200
Noche / oscuro
~400
Umbral típico
~700
Luz artificial
1023
Luz solar
🌙
1023
Valores
40'
Tiempo
P0/P1
Pines
📦 Paso 1

Materiales necesarios

Reúne estos componentes. El sensor de luz (LDR) es nuevo — tiene una resistencia que varía con la luz. Haz clic para ver su guía.

☀️
Sensor de Luz (LDR)
P0 — Analógico
×1 Ver guía completa →
🟢
LED Verde
P1 — Digital
×1 Ver guía completa →
🔌
micro:bit + Shield
Controlador
×1 Plataforma principal →
🔗
Cables Dupont
3 por módulo
×6 Info sobre cables →
🔌 Paso 2

Conexión de los componentes

El sensor de luz va en P0 (lectura analógica) y el LED en P1 (salida digital). La diferencia clave: el sensor usa analogReadPin, no digitalReadPin.

Componente Pin shield Cable recomendado
Sensor Luz — Señal P0 (analógico) Amarillo
Sensor Luz — Alimentación V (3.3V) Rojo
Sensor Luz — Tierra G (GND) Negro
LED Verde — Señal P1 Verde
LED Verde — Alimentación V (3.3V) Rojo
LED Verde — Tierra G (GND) Negro
⚠️ Importante: El pin P0 puede leer señales analógicas en el micro:bit. Los pines P1 y P2 también pueden hacerlo, pero P0 es el más común para sensores analógicos. No uses P3 (está conectado a los botones internos).
1
Conecta el sensor de luz al bloque P0 del shield: S → P0, V → V, G → G. Este sensor es analógico — su pin S devuelve un voltaje proporcional a la luz recibida.
2
Conecta el LED verde al bloque P1: S → P1, V → V, G → G. Este es digital — solo lo encendemos (1) o apagamos (0).
3
Comprueba que el sensor de luz tiene la parte con la rejilla mirando hacia arriba (hacia donde hay luz). Si está tapado, siempre leerá valores bajos.
4
Antes de ajustar el umbral, sube el código y observa los valores que aparecen en pantalla. Apunta el valor con mucha luz y el valor en oscuridad — los necesitarás para el Reto 1.
💡 Dato clave: El sensor de luz es sensible a la dirección. Si lo orientas hacia una ventana, leerá valores más altos que si mira al techo. Durante las pruebas, intenta mantener la misma orientación.
💻 Paso 3

Programación

Lo nuevo aquí es la lectura analógica y el concepto de umbral (threshold). Lee bien los comentarios antes de copiar el código.

MakeCode JavaScript 
// Luz nocturna automática
// El LED se enciende cuando la luz ambiente es baja

let nivelLuz = 0
let UMBRAL = 400  // Ajusta este valor según tu entorno (0-1023)

basic.forever(function () {
    // Leer el sensor de luz (valor entre 0 y 1023)
    nivelLuz = pins.analogReadPin(AnalogPin.P0)

    // Mostrar el valor en pantalla (para calibrar)
    basic.showNumber(nivelLuz)

    if (nivelLuz < UMBRAL) {
        // Poca luz → encender LED
        pins.digitalWritePin(DigitalPin.P1, 1)
        basic.showIcon(IconNames.Diamond)
    } else {
        // Mucha luz → apagar LED
        pins.digitalWritePin(DigitalPin.P1, 0)
        basic.showIcon(IconNames.SmallDiamond)
    }

    basic.pause(500)  // Actualizar cada 0.5 segundos
})
📊
pins.analogReadPin(AnalogPin.P0) — Lee el sensor y devuelve un número entre 0 y 1023. A diferencia de digitalReadPin (que solo da 0 o 1), aquí obtienes el valor exacto de luz. Esto se llama señal analógica.
📏
let UMBRAL = 400 — El umbral es el valor que separa "hay luz" de "no hay luz". Si el valor del sensor es menor que 400, consideramos que está oscuro. Este valor es el que debes ajustar según tu entorno (ver Reto 1).
🔢
basic.showNumber(nivelLuz) — Muestra el valor del sensor en la pantalla del micro:bit. Muy útil para la calibración. Una vez que hayas ajustado el umbral, puedes quitar esta línea.
⏱️
basic.pause(500) — El sensor se lee cada 500ms (0.5 segundos). Si lo quitas, la pantalla se actualiza tan rápido que no podrás leer los números. Los sensores analógicos no necesitan respuesta instantánea.
⚙️ Cómo calibrar el umbral — Hazlo antes del Reto 1
1Sube el código con UMBRAL = 400 y mira los números en la pantalla del micro:bit.
2Con mucha luz (cerca de una ventana o lámpara), apunta el valor. Ejemplo: 750.
3Tapa el sensor completamente con la mano y apunta ese valor. Ejemplo: 80.
4Calcula el punto medio: (750 + 80) / 2 = 415. Ese es tu umbral ideal.
5Cambia el 400 en el código por tu valor calculado. Vuelve a subir el código.
MicroPython 
from microbit import *

UMBRAL = 400  # Ajusta este valor según tu entorno

while True:
    # Leer el sensor de luz (valor entre 0 y 1023)
    nivel_luz = pin0.read_analog()

    # Mostrar el valor en pantalla (para calibrar)
    display.scroll(str(nivel_luz))

    if nivel_luz < UMBRAL:
        # Poca luz → encender LED
        pin1.write_digital(1)
        display.show(Image.DIAMOND)
    else:
        # Mucha luz → apagar LED
        pin1.write_digital(0)
        display.show(Image.SMALL_DIAMOND)

    sleep(500)
📊
pin0.read_analog() — Equivalente exacto a analogReadPin en MakeCode. Devuelve un entero entre 0 y 1023. En Python se hace con el método read_analog() del objeto pin.
🔢
display.scroll(str(nivel_luz)) — Para mostrar un número en pantalla en Python, primero debes convertirlo a texto con str(). El scroll desplaza el texto por la pantalla.
📏
UMBRAL en mayúsculas — En Python, es convención escribir las constantes (valores que no cambian en la ejecución) en MAYÚSCULAS. No es obligatorio, pero hace el código más legible.
✅ Paso 4

Pruébalo — ¿Qué debería pasar?

Con UMBRAL = 400 como punto de partida, verifica estos comportamientos. Si el LED no responde bien, necesitas calibrar el umbral (ver instrucciones arriba).

✓
Al arrancar: La pantalla del micro:bit muestra números continuamente. Esos son los valores del sensor. Obsérvalos durante 5 segundos.
✓
Con luz normal: El número en pantalla está por encima del UMBRAL (400). El LED está apagado y la pantalla muestra un diamante pequeño.
✓
Tapando el sensor: El número baja por debajo del UMBRAL. El LED se enciende automáticamente y la pantalla muestra un diamante grande.
✓
Sin tocar nada: El sistema funciona completamente solo. No hay ningún botón que pulsar. El LED responde solo a la luz.
✓
La transición: Cuando la luz está justo en el umbral, el LED puede parpadear. Es normal — los sensores analógicos fluctúan. El pause(500) lo suaviza.
📊 ¿Cuándo ajustar el umbral?
0 (oscuro) UMBRAL 1023 (luz)
LED ON ← | → LED OFF
Si el LED no se enciende nunca → sube el UMBRAL (p.ej. 600)
Si el LED nunca se apaga → baja el UMBRAL (p.ej. 200)
Si parpadea sin control → añade pause(1000) para estabilizar
El valor ideal está a medio camino entre luz y oscuridad
🎯 Retos

Actividades de ampliación

¡El primer reto es obligatorio para que el proyecto funcione bien! Los demás añaden funcionalidades nuevas.

RETO 1 ★ ⚙️
Primero ejecuta el código y observa qué valores muestra en pantalla con mucha luz y con poca luz. Luego ajusta el UMBRAL a un valor intermedio entre los dos para que el sistema sea preciso en tu entorno.
Ejemplo: Si con luz ves ~700 y tapando ves ~100, tu UMBRAL ideal es (700+100)/2 = 400. Pero si estás en una clase muy iluminada puede que necesites 600.
RETO 2 🎯
En vez de encendido/apagado, haz que el LED parpadee lentamente cuando la luz sea muy baja (por debajo de 200). Así simulas una luz de emergencia parpadeante.
Pista: Añade un segundo if: si nivel < 200, entra en un bucle de parpadeo. Si está entre 200 y UMBRAL, enciende fijo. Si está sobre UMBRAL, apaga.
RETO 3 🎯
Añade un segundo LED rojo en P2 que se encienda cuando hay DEMASIADA luz (nivel > 800). Así el sistema avisa tanto de oscuridad como de deslumbramiento.
Pista: Añade al código: if (nivelLuz > 800) pins.digitalWritePin(DigitalPin.P2, 1) y su correspondiente apagado cuando el nivel baja.
RETO 4 🎯
Crea un sistema con 3 niveles de luz: luz alta → LED apagado, luz media → LED parpadeando lento, luz baja → LED encendido fijo. Necesitarás dos umbrales distintos.
Pista: Usa dos variables: UMBRAL_BAJO = 200 y UMBRAL_ALTO = 600. Luego usa if / else if / else para los tres casos.
🔧 Solución de problemas

Problemas frecuentes

La mayoría de problemas con sensores analógicos tienen que ver con el umbral o con usar la función de lectura equivocada.

❌
"El sensor siempre da el valor 0"
✅
Verifica que el sensor de luz está en P0 y que usas analogReadPin (no digitalReadPin). Si usas la función digital, siempre devuelve 0 o 1, nunca el valor real. También comprueba que V y G están bien conectados.
❌
"El LED nunca se enciende aunque esté oscuro"
✅
Lee el valor en pantalla primero. Probablemente el umbral está demasiado bajo para tu entorno. Si el sensor da 300 en oscuridad y tu umbral es 200, el LED nunca se activará. Sube el UMBRAL a 600 o 700 y prueba de nuevo.
❌
"El LED nunca se apaga aunque haya mucha luz"
✅
El umbral está demasiado alto. Si el sensor da 500 con luz y tu umbral es 800, siempre estarás por debajo del umbral. Baja el UMBRAL a 200 o 300. El truco es observar los valores reales primero y luego ajustar.
❌
"Los valores en pantalla cambian mucho sin motivo"
✅
Esto es normal en sensores analógicos. Las pequeñas fluctuaciones de luz (sombras, movimientos) hacen variar el sensor. Puedes añadir basic.pause(1000) en lugar de 500 para que actualice más despacio y sea más estable.
🚀 Siguientes pasos

¿Quieres ir más allá?

Ahora que entiendes las señales analógicas, tienes acceso a un mundo completamente nuevo de sensores y automatizaciones.

📈
Dimmer proporcional
En lugar de ON/OFF, controla el brillo del LED de forma proporcional a la luz: cuanta más oscuridad, más brillo. Necesitarás analogWritePin para salida PWM — la base de todo control de velocidad y brillo.
📊
Registro de datos de luz
Guarda el historial de valores de luz a lo largo del día. Compara los niveles de luz en distintas horas del día o en distintos puntos del aula. Una pequeña estación de monitoreo ambiental.
🌱
Sistema de invernadero
Combina el sensor de luz con el ventilador: si hay mucha luz (hace calor), el ventilador se enciende. Si hay poca, el LED se enciende para dar luz a las plantas. Tu primer sistema con dos entradas y dos salidas.
Siguiente proyecto
Proyecto #04 — Alarma con Sensor de Movimiento
Usa el sensor PIR para detectar movimiento y activa una alarma sonora y visual. Combina todo lo aprendido: entradas, salidas y condiciones.
Siguiente proyecto →