Sensor de luz BH1750 com Arduino: medição de lux via I2C (guia completo)
Guia do sensor de lux BH1750 com Arduino: ligação I2C, modos de medição, BH1750 vs LDR, luz noturna automática e medidor de iluminação da sala de aula, com código para Uno, ESP32 e Pico.
O BH1750 é um sensor de luz digital de 16 bits que mede a luz ambiente diretamente em lux (lx) e se comunica via I2C. Ligar um BH1750 ao Arduino exige só quatro fios e, em vez de uma tensão bruta, o sensor entrega um valor em lux calibrado de fábrica e com significado real. Por isso, quando você quer de fato medir a luz, e não só distinguir “escuro ou claro”, por exemplo para verificar se uma sala de aula está iluminada o suficiente ou quanta luz uma planta recebe ao longo do dia, ele é o módulo preferido.
Normalmente ele é vendido como GY-302, uma plaquinha com regulador de 3,3 V e resistores de pull-up para o I2C. Neste post você vai aprender como o sensor funciona, o que o lux significa no dia a dia, como ele se diferencia de um LDR, quais são os modos de medição e como ligá-lo a um Arduino Uno, ESP32 e Raspberry Pi Pico. Depois vamos montar duas aplicações reais: uma luz noturna automática protegida contra o liga-desliga instável e um medidor de iluminação para sala de aula que avalia a iluminação com base em valores de norma.
O que é o BH1750 e como ele funciona?
O BH1750 é um sensor de luz ambiente fabricado pela ROHM. Dentro dele há um fotodiodo, um amplificador que converte a corrente do fotodiodo em tensão, um conversor analógico-digital (ADC) de 16 bits e uma interface I2C. A resposta espectral do fotodiodo é próxima à do olho humano, com pico em cerca de 560 nm, na região verde-amarela; ele ignora em grande parte a luz infravermelha, então o valor lido se parece com o brilho que o seu olho percebe. O sensor também foi projetado para rejeitar a cintilação de 50/60 Hz da rede elétrica, de modo que as leituras não saltam sob lâmpadas fluorescentes ou de LED. Na configuração padrão, o número bruto de 16 bits é dividido por 1,2 para obter lux: por exemplo, um valor bruto de 600 significa 600 / 1,2 = 500 lux. A biblioteca faz esse cálculo por você.
| Característica | Valor |
|---|---|
| Chip | ROHM BH1750FVI |
| Faixa de medição | Cerca de 1–54.600 lx no padrão (bruto 0–65.535); 0,11–100.000 lx com o ajuste de MTreg |
| Resolução | 0,5 lx, 1 lx ou 4 lx (depende do modo) |
| ADC | 16 bits |
| Precisão | Tipicamente ±20% |
| Tempo de medição | Cerca de 120 ms (alta resolução), 16 ms (baixa resolução) |
| Alimentação | Chip 2,4–3,6 V; módulo GY-302 3–5 V |
| Corrente | Cerca de 120 µA medindo, cerca de 0,01 µA em repouso |
| Interface | I2C, até 400 kHz |
| Endereço I2C | 0x23 (ADDR em LOW ou desconectado), 0x5C (ADDR em HIGH) |
| Pinos | VCC, GND, SCL, SDA, ADDR |
O que é lux? Valores do dia a dia
Lux é a unidade da luz que incide sobre uma superfície: 1 lux é 1 lúmen de fluxo luminoso por metro quadrado (1 lx = 1 lm/m²). O ponto principal é que o lux descreve a luz que chega à superfície que você mede, e não a lâmpada em si. A mesma lâmpada pode dar 500 lux numa mesa e 120 lux numa parede a dois metros, porque a luz de uma fonte pontual diminui com o quadrado da distância. Nossos olhos também funcionam de forma logarítmica: passar de 50 para 100 lux é muito mais perceptível do que passar de 1000 para 1050 lux. A tabela abaixo ajuda você a interpretar os números lidos do sensor.
| Ambiente | Iluminância aproximada |
|---|---|
| Lua cheia numa noite sem nuvens | 0,1–0,3 lx |
| Luz noturna, corredor pouco iluminado | 5–50 lx |
| Embaixo de um poste de rua | 10–20 lx |
| Sala de estar em casa | 50–200 lx |
| Escritório, sala de aula | 300–500 lx |
| Ao ar livre num dia nublado | 1000–10.000 lx |
| Sombra num dia de sol | 10.000–25.000 lx |
| Luz direta do sol | 32.000–100.000 lx |
BH1750 vs LDR: qual é a diferença?
Um LDR (fotorresistor) é um componente simples cuja resistência cai quando a luz aumenta. Você o liga a um pino analógico com um divisor de tensão e obtém um número de 0 a 1023; esse número depende do tipo de LDR, do valor do resistor em série, da tensão de alimentação e da temperatura. Assim, dois LDRs diferentes podem mostrar valores diferentes na mesma sala, e é preciso calibrar cada um separadamente para converter o valor em lux. Já o BH1750 é calibrado de fábrica e entrega lux diretamente: dois módulos dão resultados próximos sob a mesma luz. Em compensação, o LDR é muito barato, funciona com qualquer placa que tenha pino analógico e ainda basta para projetos simples que só precisam detectar o escuro. Outra desvantagem do LDR é a lentidão: ao passar do claro para o escuro, sua resistência pode levar centenas de milissegundos ou até segundos para se estabilizar.
| Característica | BH1750 | LDR |
|---|---|---|
| Saída | Digital, diretamente em lux | Analógica, variação de resistência |
| Calibração | Não é necessária | Necessária para lux |
| Ligação | I2C (SDA, SCL) | Pino analógico e resistor em série |
| Faixa | 1–54.600 lx (padrão) | Relativa, não linear |
| Resposta espectral | Próxima à do olho humano | Varia conforme o tipo |
| Vários no mesmo barramento | 2 (0x23 e 0x5C) | Um pino analógico separado para cada |
| Projeto indicado | Medição, registro, controle de iluminação | Detecção simples de escuro/claro |
Ligação do BH1750: Arduino Uno, ESP32 e Pico
| Pino do BH1750 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V ou 3.3V | 3V3 | 3V3(OUT) (pino 36) |
| GND | GND | GND | GND (pino 38) |
| SCL | A5 | GPIO 22 | GP5 (pino 7) |
| SDA | A4 | GPIO 21 | GP4 (pino 6) |
| ADDR | Desconectado ou GND (0x23) | Desconectado ou GND (0x23) | Desconectado ou GND (0x23) |
| LED da luz noturna (com 220 Ω) | D9 | GPIO 25 | GP15 (pino 20) |
| LEDs do medidor da sala (vermelho, amarelo, verde) | D5, D6, D7 | - | - |
Modos de medição: qual escolher?
| Modo (nome na biblioteca) | Comando | Resolução | Tempo de medição | Quando usar |
|---|---|---|---|---|
| CONTINUOUS_HIGH_RES_MODE | 0x10 | 1 lx | ~120 ms | Uso geral, padrão |
| CONTINUOUS_HIGH_RES_MODE_2 | 0x11 | 0,5 lx | ~120 ms | Ambientes pouco iluminados, medições noturnas |
| CONTINUOUS_LOW_RES_MODE | 0x13 | 4 lx | ~16 ms | Luz que muda rápido, clarões repentinos |
| ONE_TIME_HIGH_RES_MODE | 0x20 | 1 lx | ~120 ms | Projetos com bateria, dorme após medir |
| ONE_TIME_HIGH_RES_MODE_2 | 0x21 | 0,5 lx | ~120 ms | Medição com bateria e pouca luz |
| ONE_TIME_LOW_RES_MODE | 0x23 | 4 lx | ~16 ms | Medição rápida com o menor consumo |
Nos modos contínuos, o sensor continua medindo sozinho e você lê o resultado mais recente quando quiser. Nos modos de medição única, o sensor faz uma medição e depois entra em modo de economia de energia (power-down); como a corrente em repouso cai muito abaixo de 1 µA, é ideal para projetos com bateria, por exemplo aqueles que acordam a cada 10 minutos com o deep sleep do ESP32. Se quiser mudar ainda mais a sensibilidade, use o registrador de tempo de medição (MTreg). O padrão é 69; subir para 254 aumenta a sensibilidade cerca de 3,7 vezes e permite descer até 0,11 lux no modo H2. Baixar para 31 amplia a faixa para além de 100.000 lux e resolve o problema do valor travado no teto sob sol direto. Na biblioteca, isso é feito com setMTreg(valor); quanto maior o MTreg, mais demorada a medição, cerca de 440 ms com 254.
Passo a passo: sua primeira medição de lux com Arduino
- Abra o Gerenciador de Bibliotecas na Arduino IDE, digite BH1750 e instale a biblioteca “BH1750” de Christopher Laws. Se travar na instalação, veja como instalar bibliotecas no Arduino.
- Ligue o VCC do módulo ao 5V, o GND ao GND, o SCL ao A5 e o SDA ao A4; deixe o pino ADDR desconectado. Os pinos SDA e SCL ao lado do AREF no Uno são as mesmas linhas do A4 e A5.
- Carregue o código abaixo e abra o Monitor Serial em 9600 baud.
- Cubra o sensor com a mão e depois aponte a lanterna do celular para ele: você deve ver o valor saltar de poucos lux para milhares de lux.
- Se o Monitor Serial mostrar “not found” (não encontrado), confira os fios e o endereço, e verifique se o scanner I2C mostra o sensor em 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 o barramento I2C, e lightMeter.begin() liga o sensor, configura o modo escolhido e retorna true se der certo. readLightLevel() retorna a medição mais recente em lux como float; se o valor for negativo (-1 ou -2), a leitura falhou, então é um bom hábito conferir antes de usar o valor em cálculos. No modo contínuo de alta resolução, um novo resultado fica pronto a cada 120 ms aproximadamente, então rodar o loop mais rápido só faz você ler o mesmo valor de novo. Se tiver curiosidade sobre como o I2C funciona, dê uma olhada em O que é I2C.
Exemplo 1: luz noturna automática com o BH1750
O erro mais comum numa luz noturna é usar um único limite. Se você escolher um limite de 15 lux, quando o ambiente ficar em torno de 14–16 lux, como ao anoitecer, a lâmpada liga e desliga várias vezes por segundo. A solução é a histerese, ou seja, dois limites separados: a lâmpada acende quando a luz cai abaixo de 10 lux, mas só apaga quando ela sobe acima de 25 lux. Na faixa de 15 lux entre os dois, a lâmpada mantém o estado atual. No código abaixo usamos um LED ligado ao D9 por um resistor de 220 Ω; para uma lâmpada de verdade, você pode ligar um módulo relé no lugar do LED. Se usar um LED de outra cor, encontre o resistor certo com a calculadora de resistor 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}Exemplo 2: medição da iluminação da sala de aula
Em escolas e escritórios, saber se a iluminação é adequada é questão de medir, não de chutar. A norma de iluminação de interiores TS EN 12464-1, usada também na Turquia (e baseada na europeia EN 12464-1), recomenda uma média de pelo menos 300 lux na superfície de trabalho para salas de aula em geral, e 500 lux para aulas noturnas, educação de adultos e o quadro. Para uma medição correta, coloque o sensor deitado sobre uma carteira a cerca de 75–80 cm de altura, com a face sensível à luz voltada para o teto, e não deixe sua sombra cair sobre ele. Divida a sala numa grade imaginária; meça separadamente na frente, no meio, no fundo e nas carteiras do lado da janela e do corredor, depois anote a média e o menor valor. Como a luz do dia altera muito os valores, repita a medição uma vez ao meio-dia com as cortinas abertas e outra com as cortinas fechadas e só as lâmpadas acesas. Este também é um ótimo projeto de coleta de dados para uma feira de ciências ou uma competição.
| Área | Iluminância média recomendada (TS EN 12464-1) |
|---|---|
| Corredor | 100 lx |
| Sala de aula geral (fundamental e médio) | 300 lx |
| Sala de informática | 300 lx |
| Ginásio | 300 lx |
| Aulas noturnas e educação de adultos | 500 lx |
| Quadro | 500 lx |
| Laboratório | 500 lx |
| Área de leitura da biblioteca | 500 lx |
| Sala de desenho 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 com o ESP32: um LED que diminui conforme o ambiente
A mesma biblioteca BH1750 funciona no ESP32; a única diferença é que você indica os pinos I2C explicitamente com Wire.begin(21, 22). Neste exemplo, em vez de ligar e desligar a lâmpada, ajustamos o brilho do LED de forma suave conforme a luz ambiente: com 0 lux o LED fica no brilho máximo, a partir de 200 lux fica totalmente apagado e, no meio, diminui de forma linear. No ESP32, o sinal PWM é gerado pela unidade LEDC, e as funções dessa unidade mudaram com o core 3.x do Arduino; o código é separado por uma verificação de ESP_ARDUINO_VERSION_MAJOR para compilar nas duas versões. A lógica do PWM está em O que é PWM. Graças ao Wi-Fi do ESP32, você também pode enviar a mesma medição para o Home Assistant via MQTT e usá-la em automações de casa 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 com Raspberry Pi Pico e MicroPython
No Raspberry Pi Pico, você nem precisa de biblioteca extra para usar o BH1750 com MicroPython; os comandos do sensor são tão simples que dá para conversar com ele diretamente via I2C. Primeiro enviamos 0x01 (ligar) e depois 0x10 (alta resolução contínua). Em seguida, a cada leitura pegamos 2 bytes do sensor, juntamos num único número de 16 bits e dividimos por 1,2. Na saída de i2c.scan() você deve ver o número 35, que é o equivalente decimal do hexadecimal 0x23; se o ADDR estiver em HIGH, você verá 92, que é 0x5C. O código implementa a luz noturna com histerese do exemplo do Arduino usando um LED no GP15. Se você está começando com MicroPython, dê antes uma olhada em O que é o 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)Ideias de projetos com o BH1750
- Cortina inteligente: abra e feche uma cortina ou persiana automaticamente com um servo motor de acordo com o valor em lux.
- Monitoramento de luz na estufa: meça a luz que as plantas recebem ao longo do dia; se faltar luz no seu projeto de estufa inteligente, acenda a luz de cultivo.
- Seguidor solar: use dois BH1750 nos endereços 0x23 e 0x5C para descobrir de que direção vem a luz e girar o painel do seu seguidor solar para lá.
- Brilho automático da tela: ajuste o brilho de um display OLED conforme a luz ambiente, como nos celulares.
- Fotômetro para fotografia: calcule o valor de exposição para ISO 100 com a fórmula EV = log2(lux / 2,5) e mostre num display.
- Mapa de luz da sala de aula: registre as medições no Google Planilhas e desenhe um mapa de iluminação da sala; é um conjunto de dados forte para um projeto de feira de ciências.
Erros comuns e como corrigir
| Sintoma | Causa provável | Solução |
|---|---|---|
| “BH1750 not found” (não encontrado), begin() retorna false | SDA e SCL invertidos, endereço errado ou Wire.begin() esquecido | Confira os fios, rode o scanner I2C, ajuste o endereço para 0x23 ou 0x5C |
| Valor travado em torno de 54.612 | Saturação sob sol direto (65.535 / 1,2) | Amplie a faixa com setMTreg(31) |
| Valor é -1 ou -2 | Erro de leitura I2C ou sensor não configurado | Confira o retorno de begin(), encurte os fios |
| O valor nunca muda depois da primeira leitura | O sensor entrou em repouso no modo de medição única | Use o modo contínuo ou chame configure() antes de cada leitura |
| As leituras ficam oscilando | Sombra, mão, sensor inclinado | Faça uma média, fixe o sensor na horizontal e firme |
| A luz noturna fica ligando e desligando | Limite único ou o sensor está vendo a lâmpada | Adicione histerese, afaste o sensor da lâmpada |
| ESP32 ou Pico trava, erro de I2C | Módulo alimentado com 5 V ou fios longos demais | Alimente o módulo pelo 3V3, mantenha os fios com menos de 30 cm |
O BH1750 substitui o LDR com facilidade em qualquer projeto em que você queira medir a luz em vez de adivinhá-la: quatro fios, uma biblioteca e lux direto. Se uma simples detecção de escuro basta, o LDR continua sendo a solução mais barata; mas se você precisa de medição, registro ou comparação com uma norma, escolha o BH1750. No app BlueGrays você encontra projetos relacionados à luz, como leitura de intensidade luminosa com LDR e luz noturna, iluminação inteligente com ESP32 e iluminação inteligente de escada, passo a passo com esquema do circuito e código, e pode adaptar facilmente os exemplos de BH1750 deste post a eles.
Perguntas frequentes
Quantos lux o BH1750 consegue medir?
Na configuração padrão, o BH1750 mede aproximadamente de 1 a 54.600 lux com resolução de 1 lux; isso vem da divisão do valor bruto de 16 bits (65.535) por 1,2. Se você baixar o MTreg para 31, a faixa passa de 100.000 lux e ele consegue medir a luz direta do sol. Se subir o MTreg para 254 e usar o modo H2, dá para distinguir luz fraca até 0,11 lux.
Qual é o endereço I2C do BH1750?
O endereço é 0x23 quando o pino ADDR fica desconectado ou ligado ao GND, e 0x5C quando é ligado a 3,3 V. Isso permite colocar dois BH1750 no mesmo barramento I2C. Se precisar de mais sensores, você vai precisar de um multiplexador I2C como o TCA9548A.
O que é melhor, BH1750 ou LDR?
Para medição de verdade, o BH1750 é muito melhor; ele entrega lux diretamente, não precisa de calibração e responde de forma parecida com o olho humano. O LDR é mais barato e só serve para luzes noturnas simples que precisam apenas detectar quando começa a escurecer. Se você vai registrar valores ou compará-los com uma norma, escolha o BH1750.
O BH1750 funciona com 5 V?
O chip BH1750 funciona com 2,4–3,6 V, mas módulos como o GY-302 têm um regulador de 3,3 V, então o módulo pode ser alimentado com 3–5 V e ligado direto a um Arduino Uno. No ESP32 e no Raspberry Pi Pico, alimente o módulo pelo pino 3V3, para que as linhas I2C também fiquem em 3,3 V.
O BH1750 pode ser usado sob o sol e ao ar livre?
Pode, mas na configuração padrão, sob sol direto, o valor trava em cerca de 54.600 lux; você contorna isso com setMTreg(31). Use uma tampa transparente para proteger o sensor da chuva, mas lembre-se de que a tampa absorve parte da luz e ajuste os resultados com um fator de correção. Também é importante não fechar a placa numa caixa preta, onde ela esquentaria diretamente.
Por que a leitura do meu BH1750 é diferente da de um luxímetro?
A precisão típica do sensor é de ±20%, e o ângulo da luz incidente e o espectro de cor da lâmpada também afetam o resultado. Coloque o sensor no mesmo lugar e no mesmo ângulo do luxímetro, compare os dois sob algumas luzes diferentes e depois adicione a razão entre eles ao seu código como fator de correção. Também cuide para que sua própria sombra não caia sobre o sensor durante a medição.
Projetos para montar depois desta leitura
Ver todos os projetos
Medição da intensidade da luz com LDR
Quer ver a luminosidade do seu quarto em números? O LDR, um pequeno componente sensível à luz, mede a luz ambiente, e o Arduino exibe o valor na tela do computador a cada meio segundo.

Luz noturna com LDR
Uma pequena luz noturna que acende sozinha quando escurece e apaga ao amanhecer.

Leitura da intensidade da luz com módulo LDR e ESP32
Acompanhe em tempo real no Monitor Serial o valor bruto do ADC do módulo LDR e a porcentagem relativa de luz calculada a partir de referências de escuridão e claridade. Essa porcentagem não é uma medida em lux. O projeto ensina a lógica de calibração do módulo. É ideal fazê-lo antes do projeto 10, pois ajuda a determinar o valor do limiar.

Luz noturna com LDR e ESP32
Uma luz noturna em que o LED acende automaticamente no escuro e apaga na claridade. Usamos o pino D0 (saída digital) do módulo sensor LDR. O pequeno potenciômetro no módulo ajusta o limiar de escuridão, e o próprio módulo gera a saída HIGH/LOW. O ESP32 apenas lê esse sinal com digitalRead(), deixando o código bem simples.

Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)
Transforme a iluminação do corredor, banheiro ou despensa em iluminação inteligente com ESP32! Com um sensor de movimento PIR, um sensor de luz LDR e um módulo relé, montamos o cenário clássico de "acender a luz ao detectar movimento no escuro" — se o ambiente já estiver claro, o movimento NÃO aciona a luz, economizando energia durante o dia. A luz fica acesa por 30 segundos; se o movimento continuar, o temporizador reinicia e a luz permanece acesa por mais tempo.

Iluminação inteligente de escadas e corredores
Ao entrar na escada ou no corredor, as luzes acendem uma a uma no sentido em que você caminha.

Uso do display LCD com I2C
Dê ao seu Arduino um display próprio e faça-o escrever sua primeira mensagem. O display LCD de duas linhas é conectado com poucos fios; primeiro aparece uma saudação na linha de cima, depois uma…

Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)
O LED não só pisca — ele respira! Com o PWM (modulação por largura de pulso) do Raspberry Pi Pico, o brilho do LED aumenta e diminui lentamente, como a luz de um MacBook em repouso. Aprenda a usar a classe machine.PWM, duty_u16() (brilho de 16 bits, de 0–65535), frequência PWM (freq(1000) — 1.000 ciclos de ligar/desligar por segundo, sem cintilação visível), laços com passos usando range() (crescentes e decrescentes) e saída semelhante à analógica em um pino digital.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

