Sensor de luz BH1750 Arduino: medir lux paso a paso
Sensor de luz BH1750 Arduino: conexión I2C, modos de medición, diferencia con LDR, luz nocturna automática y medidor de aula; código para Uno, ESP32 y Pico.
El BH1750 es un sensor de luz digital de 16 bits con interfaz I2C que mide la cantidad de luz ambiental directamente en lux (lx). La conexión del BH1750 con Arduino necesita solo cuatro cables y, en lugar de un voltaje en bruto, el sensor te da un valor en lux calibrado de fábrica y con sentido. Por eso es el módulo preferido cuando quieres medir la luz de verdad y no solo distinguir "oscuro o claro", por ejemplo para saber si un aula está suficientemente iluminada o cuánta luz recibe una planta durante el día.
Normalmente se vende con el nombre GY-302, una placa pequeña con regulador de 3,3 V y resistencias pull-up para I2C. En este artículo aprenderás cómo funciona el sensor, a qué equivale el lux en la vida diaria, en qué se diferencia de un LDR, cuáles son sus modos de medición y cómo conectarlo a Arduino Uno, ESP32 y Raspberry Pi Pico. Después haremos dos aplicaciones reales: una luz nocturna automática protegida contra encendidos y apagados inestables y un medidor de iluminación de aula que da una valoración según los valores estándar.
¿Qué es el BH1750 y cómo funciona?
El BH1750 es un sensor de luz ambiental fabricado por ROHM. Dentro tiene un fotodiodo, un amplificador que convierte la corriente del fotodiodo en tensión, un convertidor analógico-digital (ADC) de 16 bits y la interfaz I2C. La sensibilidad espectral del fotodiodo es parecida a la del ojo humano, con un máximo de unos 560 nm, en la zona verde-amarilla; así ignora en gran parte la luz infrarroja y el valor que mide se parece al brillo que percibes. Además está diseñado para suprimir el parpadeo de la red de 50/60 Hz, de modo que las lecturas no saltan bajo lámparas fluorescentes o LED. El número bruto de 16 bits se convierte a lux dividiéndolo entre 1,2 con el ajuste por defecto: si el valor bruto es 600, la luz ambiental es 600 / 1,2 = 500 lux. La librería hace este cálculo por ti.
| Característica | Valor |
|---|---|
| Chip | ROHM BH1750FVI |
| Rango de medición | Con el ajuste por defecto, aprox. 1–54 600 lx (bruto 0–65 535); con MTreg, 0,11–100 000 lx |
| Resolución | 0,5 lx, 1 lx o 4 lx (según el modo) |
| ADC | 16 bits |
| Precisión | Típica ±20 % |
| Tiempo de medición | Aprox. 120 ms (alta resolución), 16 ms (baja resolución) |
| Alimentación | Chip 2,4–3,6 V; módulo GY-302 3–5 V |
| Corriente | Aprox. 120 µA midiendo, aprox. 0,01 µA en reposo |
| Interfaz | I2C, hasta 400 kHz |
| Dirección I2C | 0x23 (ADDR a GND o sin conectar), 0x5C (ADDR a nivel alto) |
| Pines | VCC, GND, SCL, SDA, ADDR |
¿Qué es el lux? Valores de la vida diaria
El lux es la unidad de la cantidad de luz que cae sobre una superficie: 1 lux es un flujo luminoso de 1 lumen sobre un metro cuadrado (1 lx = 1 lm/m²). Lo importante es que el lux no describe la lámpara en sí, sino la luz que llega a la superficie que mides. La misma lámpara puede dar 500 lux sobre la mesa y 120 lux sobre la pared a dos metros, porque la luz de una fuente puntual disminuye con el cuadrado de la distancia. Nuestro ojo, en cambio, funciona de forma logarítmica: pasar de 50 a 100 lux se nota mucho más que pasar de 1000 a 1050 lux. La tabla siguiente te ayuda a interpretar los números que leas del sensor.
| Entorno | Iluminancia aproximada |
|---|---|
| Luna llena en una noche despejada | 0,1–0,3 lx |
| Luz nocturna, pasillo con poca luz | 5–50 lx |
| Bajo una farola | 10–20 lx |
| Salón de una casa | 50–200 lx |
| Oficina, aula | 300–500 lx |
| Exterior con cielo cubierto | 1000–10 000 lx |
| Sombra en un día soleado | 10 000–25 000 lx |
| Luz solar directa | 32 000–100 000 lx |
Diferencia entre el BH1750 y un LDR
El LDR (fotorresistencia) es un componente simple cuya resistencia disminuye al aumentar la luz. Se conecta a un pin analógico con un divisor de tensión y te da un número entre 0 y 1023 que depende del tipo de LDR, del valor de la resistencia en serie, de la tensión de alimentación y de la temperatura. Es decir, dos LDR distintos pueden mostrar valores diferentes en la misma habitación y tienes que calibrar cada uno por separado para convertir el valor a lux. El BH1750, en cambio, es un sensor calibrado de fábrica que da lux directamente: dos módulos con la misma luz dan resultados muy parecidos. Por otro lado, el LDR es muy barato, se conecta a cualquier placa con pin analógico y sigue siendo suficiente para proyectos simples que solo necesitan detectar la oscuridad. Otra desventaja del LDR es su lentitud: al pasar de luz a oscuridad, su resistencia puede tardar cientos de milisegundos o incluso segundos en estabilizarse.
| Característica | BH1750 | LDR |
|---|---|---|
| Salida | Digital, directamente en lux | Analógica, variación de resistencia |
| Calibración | No necesaria | Necesaria para obtener lux |
| Conexión | I2C (SDA, SCL) | Pin analógico y resistencia en serie |
| Rango | 1–54 600 lx (por defecto) | Relativo, no lineal |
| Respuesta espectral | Parecida al ojo humano | Varía según el tipo |
| Varios en el mismo bus | 2 (0x23 y 0x5C) | Un pin analógico para cada uno |
| Proyecto adecuado | Medición, registro, control de iluminación | Detección simple de oscuridad/luz |
Conexión del BH1750: Arduino Uno, ESP32 y Pico
| Pin del BH1750 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V o 3.3V | 3V3 | 3V3(OUT) (pin 36) |
| GND | GND | GND | GND (pin 38) |
| SCL | A5 | GPIO 22 | GP5 (pin 7) |
| SDA | A4 | GPIO 21 | GP4 (pin 6) |
| ADDR | Sin conectar o a GND (0x23) | Sin conectar o a GND (0x23) | Sin conectar o a GND (0x23) |
| LED de la luz nocturna (con 220 Ω) | D9 | GPIO 25 | GP15 (pin 20) |
| LED del medidor de aula (rojo, amarillo, verde) | D5, D6, D7 | - | - |
Modos de medición: ¿cuál elegir?
| Modo (nombre en la librería) | Comando | Resolución | Tiempo de medición | ¿Cuándo? |
|---|---|---|---|---|
| CONTINUOUS_HIGH_RES_MODE | 0x10 | 1 lx | ~120 ms | Uso general, por defecto |
| CONTINUOUS_HIGH_RES_MODE_2 | 0x11 | 0,5 lx | ~120 ms | Ambientes con poca luz, medición nocturna |
| CONTINUOUS_LOW_RES_MODE | 0x13 | 4 lx | ~16 ms | Luz que cambia rápido, destellos |
| ONE_TIME_HIGH_RES_MODE | 0x20 | 1 lx | ~120 ms | Proyectos con pilas, duerme tras medir |
| ONE_TIME_HIGH_RES_MODE_2 | 0x21 | 0,5 lx | ~120 ms | Pilas y medición con poca luz |
| ONE_TIME_LOW_RES_MODE | 0x23 | 4 lx | ~16 ms | Medición rápida con el mínimo de energía |
En los modos continuos el sensor sigue midiendo por su cuenta y tú lees el último resultado cuando quieras. En los modos de una sola medida, el sensor mide una vez y pasa al modo de ahorro de energía; como en reposo su corriente baja muy por debajo de 1 µA, es ideal para proyectos con pilas que se despiertan, por ejemplo, cada 10 minutos con ESP32 deep sleep. Si quieres cambiar aún más la sensibilidad, puedes usar el registro de tiempo de medición (MTreg). El valor por defecto es 69; subirlo a 254 aumenta la sensibilidad unas 3,7 veces y en el modo H2 permite llegar hasta 0,11 lux. Bajarlo a 31 amplía el rango de medición por encima de 100 000 lux y resuelve el problema de que el valor se quede en el máximo bajo el sol directo. En la librería se hace con setMTreg(valor); cuanto mayor es MTreg, más largo es el tiempo de medición, unos 440 ms con 254.
Paso a paso: primera medición de lux con Arduino
- Abre el Gestor de bibliotecas en el IDE de Arduino, escribe BH1750 e instala la librería "BH1750" de Christopher Laws. Si te atascas con la instalación, mira el artículo cómo añadir librerías a Arduino.
- Conecta VCC del módulo a 5V, GND a GND, SCL a A5 y SDA a A4; deja el pin ADDR sin conectar. Los pines SDA y SCL junto a AREF en el Uno son la misma línea que A4 y A5.
- Sube el código siguiente y abre el Monitor serie a 9600 baudios.
- Tapa el sensor con la mano y luego acércalo a la linterna del móvil: el valor debería pasar de unos pocos lux a miles de lux.
- Si el Monitor serie muestra "not found", revisa los cables y la dirección, y comprueba con un escáner I2C que el sensor aparece en 0x23.
1#include <Wire.h>
2#include <BH1750.h>
3
4BH1750 lightMeter; // BH1750 nesnesi / BH1750 object
5
6void setup() {
7 Serial.begin(9600);
8 Wire.begin(); // I2C hattını başlat / start the I2C bus
9 if (lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE, 0x23)) { // ADDR boş ya da GND / ADDR floating or GND
10 Serial.println(F("BH1750 hazir / ready"));
11 } else {
12 Serial.println(F("BH1750 bulunamadi / not found"));
13 while (true) {} // burada dur / stop here
14 }
15}
16
17void loop() {
18 float lux = lightMeter.readLightLevel(); // lüks cinsinden ölçüm / reading in lux
19 if (lux < 0) { // negatif değer = hata / negative value = error
20 Serial.println(F("Okuma hatasi / Read error"));
21 } else {
22 Serial.print(F("Isik / Light: "));
23 Serial.print(lux, 1);
24 Serial.println(F(" lx"));
25 }
26 delay(500);
27}Wire.begin() inicia el bus I2C, y lightMeter.begin() alimenta el sensor, configura el modo elegido y devuelve true si todo va bien. readLightLevel() devuelve la última medición en lux como float; si el valor es negativo (-1 o -2), la lectura ha fallado, así que conviene comprobarlo antes de usarlo en cálculos. En el modo continuo de alta resolución un resultado nuevo está listo aproximadamente cada 120 ms, de modo que ejecutar el bucle más rápido solo te hace leer el mismo valor otra vez. Si quieres saber cómo funciona I2C, echa un vistazo a qué es I2C.
Ejemplo 1: luz nocturna automática con BH1750
El error más habitual en una luz nocturna es usar un solo umbral. Si eliges 15 lux, cuando el ambiente ronda los 14–16 lux, por ejemplo al atardecer, la lámpara se enciende y se apaga varias veces por segundo. La solución es la histéresis, es decir, dos umbrales distintos: la lámpara se enciende cuando la luz baja de 10 lux, pero solo se apaga cuando sube por encima de 25 lux. En la zona intermedia de 15 lux la lámpara mantiene su estado. En el código siguiente usamos un LED conectado a D9 con una resistencia de 220 Ω; para una lámpara real puedes conectar un módulo de relé en lugar del LED. Si usas un LED de otro color, calcula la resistencia correcta con la calculadora de resistencia para LED.
1#include <Wire.h>
2#include <BH1750.h>
3
4BH1750 lightMeter;
5const int LED_PIN = 9; // LED + 220 ohm direnç / LED + 220 ohm resistor
6const float ON_LUX = 10.0; // bunun altında yak / turn on below this
7const float OFF_LUX = 25.0; // bunun üstünde söndür / turn off above this
8bool lampOn = false;
9
10void setup() {
11 Serial.begin(9600);
12 pinMode(LED_PIN, OUTPUT);
13 Wire.begin();
14 lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE, 0x23);
15}
16
17void loop() {
18 float lux = lightMeter.readLightLevel();
19 if (lux < 0) { // okuma hatası / read error
20 Serial.println(F("Sensor hatasi / Sensor error"));
21 delay(1000);
22 return;
23 }
24 if (!lampOn && lux < ON_LUX) { // karanlık oldu / it got dark
25 lampOn = true;
26 } else if (lampOn && lux > OFF_LUX) { // yeterince aydınlık / bright enough
27 lampOn = false;
28 }
29 digitalWrite(LED_PIN, lampOn ? HIGH : LOW);
30 Serial.print(lux, 1);
31 Serial.print(F(" lx lamba / lamp: "));
32 Serial.println(lampOn ? F("ACIK / ON") : F("KAPALI / OFF"));
33 delay(500);
34}Ejemplo 2: medición de la iluminación de un aula
En colegios y oficinas, saber si la iluminación es suficiente no se adivina: se mide. La norma de iluminación de interiores EN 12464-1 (en Turquía TS EN 12464-1) recomienda en el plano de trabajo una media de al menos 300 lux para aulas generales y 500 lux para clases nocturnas, educación de adultos y pizarra. Para medir bien, coloca el sensor sobre el pupitre, a unos 75–80 cm de altura, en horizontal y con la cara sensible hacia el techo, sin proyectar tu propia sombra sobre él. Divide el aula en una cuadrícula imaginaria; mide por separado en los pupitres de delante, del medio, del fondo y en los lados de la ventana y del pasillo, y anota la media y el valor más bajo. Como la luz natural cambia mucho los valores, repite la medición una vez a mediodía con las cortinas abiertas y otra con las cortinas cerradas y solo las lámparas encendidas. Es también un proyecto muy sólido de recogida de datos para una feria de ciencias o un concurso.
| Zona | Iluminancia media recomendada (TS EN 12464-1) |
|---|---|
| Pasillo | 100 lx |
| Aula general (primaria y secundaria) | 300 lx |
| Aula de informática | 300 lx |
| Gimnasio | 300 lx |
| Clases nocturnas y educación de adultos | 500 lx |
| Pizarra | 500 lx |
| Laboratorio | 500 lx |
| Zona de lectura de la biblioteca | 500 lx |
| Aula de dibujo técnico | 750 lx |
1#include <Wire.h>
2#include <BH1750.h>
3
4BH1750 lightMeter;
5const int RED_PIN = 5; // yetersiz / too dark
6const int YELLOW_PIN = 6; // sınırda / borderline
7const int GREEN_PIN = 7; // uygun / good
8
9float averageLux(int samples) {
10 float sum = 0;
11 int count = 0;
12 for (int i = 0; i < samples; i++) {
13 float lux = lightMeter.readLightLevel();
14 if (lux >= 0) { // hatalı okumaları atla / skip failed readings
15 sum += lux;
16 count++;
17 }
18 delay(150); // yeni ölçüm ~120 ms'de hazır / a new reading is ready every ~120 ms
19 }
20 if (count == 0) return -1;
21 return sum / count;
22}
23
24void setLeds(bool r, bool y, bool g) {
25 digitalWrite(RED_PIN, r ? HIGH : LOW);
26 digitalWrite(YELLOW_PIN, y ? HIGH : LOW);
27 digitalWrite(GREEN_PIN, g ? HIGH : LOW);
28}
29
30void setup() {
31 Serial.begin(9600);
32 pinMode(RED_PIN, OUTPUT);
33 pinMode(YELLOW_PIN, OUTPUT);
34 pinMode(GREEN_PIN, OUTPUT);
35 Wire.begin();
36 if (!lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE_2, 0x23)) { // 0,5 lx çözünürlük / 0.5 lx resolution
37 Serial.println(F("BH1750 bulunamadi / not found"));
38 while (true) {}
39 }
40}
41
42void loop() {
43 float lux = averageLux(20); // yaklaşık 3 sn ortalama / about 3 s average
44 if (lux < 0) {
45 setLeds(false, false, false);
46 Serial.println(F("Okuma hatasi / Read error"));
47 return;
48 }
49 Serial.print(F("Ortalama / Average: "));
50 Serial.print(lux, 1);
51 Serial.print(F(" lx -> "));
52 if (lux < 200) {
53 setLeds(true, false, false);
54 Serial.println(F("Yetersiz / Too dark"));
55 } else if (lux < 300) {
56 setLeds(false, true, false);
57 Serial.println(F("Sinirda / Borderline"));
58 } else if (lux < 500) {
59 setLeds(false, false, true);
60 Serial.println(F("Sinif icin uygun / OK for classroom"));
61 } else {
62 setLeds(false, false, true);
63 Serial.println(F("Tahta ve aksam dersi icin de uygun / OK for board and evening classes"));
64 }
65}BH1750 con ESP32: LED que se atenúa según el ambiente
En el ESP32 funciona la misma librería BH1750; la única diferencia es que indicas los pines I2C explícitamente con Wire.begin(21, 22). En este ejemplo, en lugar de encender y apagar la lámpara, ajustamos el brillo del LED de forma continua según la luz ambiente: con 0 lux el LED está al máximo, con 200 lux o más está totalmente apagado y entre medias se atenúa de forma lineal. En el ESP32 la señal PWM se genera con la unidad LEDC y sus funciones cambiaron con el core Arduino 3.x; el código se separa con una comprobación de ESP_ARDUINO_VERSION_MAJOR para compilar en ambas versiones. Puedes ver la lógica del PWM en qué es PWM. Gracias al Wi-Fi del ESP32 también puedes enviar la misma medición por MQTT a Home Assistant y usarla en automatizaciones del hogar inteligente.
1#include <Wire.h>
2#include <BH1750.h>
3#include <esp_arduino_version.h>
4
5BH1750 lightMeter;
6const int LED_PIN = 25; // LED + 220 ohm direnç / LED + 220 ohm resistor
7const int PWM_FREQ = 5000; // 5 kHz PWM
8const int PWM_RES = 8; // 8 bit: 0-255
9const float FULL_DARK_LUX = 200.0; // bu değerde LED tamamen söner / LED fully off at this value
10#if ESP_ARDUINO_VERSION_MAJOR < 3
11const int PWM_CHANNEL = 0; // core 2.x için LEDC kanalı / LEDC channel for core 2.x
12#endif
13
14void setupPwm() {
15#if ESP_ARDUINO_VERSION_MAJOR >= 3
16 ledcAttach(LED_PIN, PWM_FREQ, PWM_RES);
17#else
18 ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_RES);
19 ledcAttachPin(LED_PIN, PWM_CHANNEL);
20#endif
21}
22
23void writePwm(int duty) {
24#if ESP_ARDUINO_VERSION_MAJOR >= 3
25 ledcWrite(LED_PIN, duty);
26#else
27 ledcWrite(PWM_CHANNEL, duty);
28#endif
29}
30
31void setup() {
32 Serial.begin(115200);
33 Wire.begin(21, 22); // SDA, SCL
34 if (!lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE, 0x23, &Wire)) {
35 Serial.println("BH1750 bulunamadi / not found");
36 }
37 setupPwm();
38}
39
40void loop() {
41 float lux = lightMeter.readLightLevel();
42 if (lux >= 0) {
43 float limited = constrain(lux, 0.0f, FULL_DARK_LUX);
44 int duty = (int)(255.0f * (1.0f - limited / FULL_DARK_LUX)); // karanlıkta parlak / bright in the dark
45 writePwm(duty);
46 Serial.printf("%.1f lx -> PWM %d\n", lux, duty);
47 } else {
48 Serial.println("Okuma hatasi / Read error");
49 }
50 delay(200);
51}BH1750 con Raspberry Pi Pico y MicroPython
En la Raspberry Pi Pico con MicroPython no necesitas ni una librería adicional para usar el BH1750; los comandos del sensor son tan sencillos que puedes hablar directamente por I2C. Primero enviamos el comando 0x01 (encender) y luego 0x10 (alta resolución continua). Después, en cada lectura, tomamos 2 bytes del sensor, los combinamos en un único número de 16 bits y lo dividimos entre 1,2. En la salida de i2c.scan() deberías ver el número 35, que es el equivalente decimal de 0x23; si ADDR está a nivel alto verás 92, es decir, 0x5C. El código aplica la luz nocturna con histéresis del ejemplo de Arduino con un LED conectado a GP15. Si eres nuevo en MicroPython, mira primero qué es la Raspberry Pi Pico.
1from machine import Pin, I2C
2import time
3
4BH1750_ADDR = 0x23 # ADDR boş ya da GND / ADDR floating or GND
5POWER_ON = 0x01 # güç aç komutu / power on command
6CONT_H_RES = 0x10 # sürekli yüksek çözünürlük / continuous high resolution
7
8i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
9print(i2c.scan()) # [35] görmelisin (0x23) / you should see [35] (0x23)
10
11led = Pin(15, Pin.OUT) # LED + 220 ohm direnç / LED + 220 ohm resistor
12
13i2c.writeto(BH1750_ADDR, bytes([POWER_ON]))
14i2c.writeto(BH1750_ADDR, bytes([CONT_H_RES]))
15time.sleep_ms(180) # ilk ölçümü bekle / wait for the first measurement
16
17def read_lux():
18 data = i2c.readfrom(BH1750_ADDR, 2) # 2 bayt oku / read 2 bytes
19 raw = (data[0] << 8) | data[1] # 16 bit ham değer / 16-bit raw value
20 return raw / 1.2 # lükse çevir / convert to lux
21
22lamp_on = False
23while True:
24 lux = read_lux()
25 if not lamp_on and lux < 10: # karanlık oldu / it got dark
26 lamp_on = True
27 elif lamp_on and lux > 25: # yeterince aydınlık / bright enough
28 lamp_on = False
29 led.value(1 if lamp_on else 0)
30 print("{:.1f} lx".format(lux))
31 time.sleep_ms(500)Ideas de proyectos con el BH1750
- Cortina inteligente: abre y cierra automáticamente una cortina o persiana con un servomotor según el valor en lux.
- Seguimiento de luz en un invernadero: mide la luz que reciben las plantas durante el día; si en tu invernadero inteligente la luz es insuficiente, enciende la lámpara de cultivo.
- Seguidor solar: con dos BH1750 en las direcciones 0x23 y 0x5C, encuentra de dónde viene la luz y gira el panel de tu sistema de seguimiento solar hacia esa dirección.
- Brillo de pantalla automático: como en los móviles, ajusta el brillo de una pantalla OLED según la luz ambiente.
- Fotómetro de cámara: calcula el valor de exposición para ISO 100 con la fórmula EV = log2(lux / 2,5) y muéstralo en una pantalla.
- Mapa de luz del aula: guarda las mediciones en Google Sheets y crea el mapa de iluminación del aula; es un conjunto de datos excelente para un proyecto de ciencias.
Errores comunes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| "BH1750 not found", begin() devuelve false | SDA y SCL invertidos, dirección incorrecta o falta Wire.begin() | Revisa los cables, ejecuta un escáner I2C, usa la dirección 0x23 o 0x5C |
| El valor se queda en torno a 54 612 | Saturación bajo el sol directo (65 535 / 1,2) | Amplía el rango de medición con setMTreg(31) |
| El valor es -1 o -2 | Error de lectura I2C o sensor sin configurar | Comprueba lo que devuelve begin(), acorta los cables |
| Tras la primera lectura el valor no cambia | En modo de una sola medida el sensor se ha dormido | Usa el modo continuo o llama a configure() antes de cada lectura |
| Las lecturas oscilan constantemente | Sombras, la mano, sensor inclinado | Haz un promedio y coloca el sensor en horizontal y fijo |
| La luz nocturna se enciende y apaga | Un solo umbral o el sensor ve la lámpara | Añade histéresis, aleja el sensor de la lámpara |
| El ESP32 o la Pico se cuelga o da error I2C | Módulo alimentado a 5 V o cables demasiado largos | Alimenta el módulo con 3V3, mantén los cables por debajo de 30 cm |
El BH1750 sustituye sin problema al LDR en cualquier proyecto en el que quieras medir la luz en lugar de adivinarla: cuatro cables, una librería y lux directos. Si te basta con una detección simple de oscuridad, el LDR sigue siendo la solución más barata; pero si necesitas medir, registrar o comparar con una norma, elige el BH1750. En la aplicación de BlueGrays encontrarás, con esquemas de conexión y código paso a paso, proyectos relacionados con la luz como la lectura de intensidad lumínica con LDR y luz nocturna, la iluminación inteligente con ESP32 y la iluminación inteligente de escaleras, y podrás adaptar fácilmente a ellos los ejemplos del BH1750 de este artículo.
Preguntas frecuentes
¿Cuántos lux puede medir el BH1750?
Con el ajuste por defecto, el BH1750 mide aproximadamente entre 1 y 54 600 lux con una resolución de 1 lux; esto sale de dividir el valor bruto de 16 bits (65 535) entre 1,2. Si bajas MTreg a 31, el rango supera los 100 000 lux para medir luz solar directa. Si subes MTreg a 254 y usas el modo H2, puedes distinguir luz tenue hasta 0,11 lux.
¿Cuál es la dirección I2C del BH1750?
Si dejas el pin ADDR sin conectar o lo conectas a GND, la dirección es 0x23; si lo conectas a 3,3 V, es 0x5C. Así puedes conectar dos BH1750 al mismo bus I2C. Si necesitas más sensores, tendrás que usar un multiplexor I2C como el TCA9548A.
¿Es mejor el BH1750 o un LDR?
Para medir de verdad, el BH1750 es mucho mejor: da lux directamente, no necesita calibración y responde de forma parecida al ojo humano. El LDR es más barato y solo basta para luces nocturnas simples que únicamente deben detectar cuándo empieza la oscuridad. Si vas a registrar valores o compararlos con una norma, elige el BH1750.
¿Funciona el BH1750 a 5 V?
El chip BH1750 funciona con 2,4–3,6 V, pero los módulos como el GY-302 llevan un regulador de 3,3 V, así que el módulo se puede alimentar con 3–5 V y conectar directamente a un Arduino Uno. En el ESP32 y la Raspberry Pi Pico debes alimentar el módulo desde el pin 3V3; así las líneas I2C también se quedan a 3,3 V.
¿Se puede usar el BH1750 al sol y en exteriores?
Sí, pero con el ajuste por defecto, bajo el sol directo el valor se queda en unos 54 600 lux; puedes superarlo con setMTreg(31). Para proteger el sensor de la lluvia usa una cubierta transparente, pero recuerda que absorberá parte de la luz y ajusta los resultados con un factor de corrección. También conviene no meter la placa en una caja negra donde se caliente directamente.
¿Por qué el valor del BH1750 es distinto al de un luxómetro?
La precisión típica del sensor es ±20 %, y además el ángulo de incidencia de la luz y el espectro de color de la lámpara afectan al resultado. Coloca el sensor en el mismo lugar y con el mismo ángulo que el luxómetro, compáralos con varias luces distintas y añade la proporción entre ambos como factor de corrección en tu código. Procura también que tu propia sombra no caiga sobre el sensor durante la medición.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Medir la intensidad de luz con LDR
¿Quieres ver en números cuánta luz hay en tu habitación? El LDR, una pequeña pieza sensible a la luz, mide la luz ambiente y el Arduino escribe el valor en la pantalla del ordenador cada medio…

Luz nocturna con LDR
Una pequeña lamparita que se enciende sola cuando oscurece y se apaga cuando llega la mañana.

Lectura de la intensidad luminosa con el módulo LDR del ESP32
Visualización en tiempo real en el monitor serie del valor bruto del ADC del módulo LDR y del porcentaje relativo de luz calculado a partir de referencias de oscuridad y claridad. Este porcentaje no es una medición en lux. Explica el funcionamiento de la calibración del módulo. Es recomendable realizarlo antes del Proyecto 10, ya que se utiliza para determinar el valor umbral.

ESP32 Luz de Noche con LDR
Luz nocturna en la que el LED se enciende automáticamente en la oscuridad y se apaga con la luz. Se utiliza el pin D0 (digital out) del módulo sensor LDR - el umbral de oscuridad se ajusta con el pequeño potenciómetro del módulo, el propio módulo genera la salida HIGH/LOW. ESP32 sólo lee esta señal con digitalRead(), el código es muy simple.

Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
Con un ESP32, un sensor de movimiento PIR, un sensor de luz LDR y un módulo de relé convertimos el pasillo, el baño o la despensa de tu casa en iluminación inteligente. Si ya hay luz, la lámpara no se enciende aunque haya movimiento, así no gasta energía de día. La luz se queda encendida 30 segundos y el tiempo se alarga solo mientras siga habiendo movimiento.

Iluminación inteligente de escaleras y pasillos
Pisas la escalera o entras en el pasillo y las luces se encienden escalón a escalón en la dirección en la que caminas.

Uso de la pantalla LCD con I2C
Dale a tu Arduino su propia pantalla y haz que escriba su primer mensaje. La pantalla LCD de dos líneas se conecta con solo unos pocos cables; primero aparece un saludo en la línea de arriba, luego…

Raspberry Pi Pico PWM LED Fade (Efecto Respiración)
¡El LED ya no solo parpadea — respira! Con el PWM (modulación por ancho de pulso) del Raspberry Pi Pico, el brillo sube y baja lentamente. Aprende la clase machine.PWM, duty_u16() (brillo de 16 bits 0–65535), la frecuencia PWM, bucles range() y salida tipo analógica. Base para mezcla de color RGB, control de motores, servos y buzzer.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

