Componentes · 11 min de leitura

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ísticaValor
ChipROHM BH1750FVI
Faixa de mediçãoCerca de 1–54.600 lx no padrão (bruto 0–65.535); 0,11–100.000 lx com o ajuste de MTreg
Resolução0,5 lx, 1 lx ou 4 lx (depende do modo)
ADC16 bits
PrecisãoTipicamente ±20%
Tempo de mediçãoCerca de 120 ms (alta resolução), 16 ms (baixa resolução)
AlimentaçãoChip 2,4–3,6 V; módulo GY-302 3–5 V
CorrenteCerca de 120 µA medindo, cerca de 0,01 µA em repouso
InterfaceI2C, até 400 kHz
Endereço I2C0x23 (ADDR em LOW ou desconectado), 0x5C (ADDR em HIGH)
PinosVCC, 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.

AmbienteIluminância aproximada
Lua cheia numa noite sem nuvens0,1–0,3 lx
Luz noturna, corredor pouco iluminado5–50 lx
Embaixo de um poste de rua10–20 lx
Sala de estar em casa50–200 lx
Escritório, sala de aula300–500 lx
Ao ar livre num dia nublado1000–10.000 lx
Sombra num dia de sol10.000–25.000 lx
Luz direta do sol32.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ísticaBH1750LDR
SaídaDigital, diretamente em luxAnalógica, variação de resistência
CalibraçãoNão é necessáriaNecessária para lux
LigaçãoI2C (SDA, SCL)Pino analógico e resistor em série
Faixa1–54.600 lx (padrão)Relativa, não linear
Resposta espectralPróxima à do olho humanoVaria conforme o tipo
Vários no mesmo barramento2 (0x23 e 0x5C)Um pino analógico separado para cada
Projeto indicadoMedição, registro, controle de iluminaçãoDetecção simples de escuro/claro

Ligação do BH1750: Arduino Uno, ESP32 e Pico

Pino do BH1750Arduino UnoESP32Raspberry Pi Pico
VCC5V ou 3.3V3V33V3(OUT) (pino 36)
GNDGNDGNDGND (pino 38)
SCLA5GPIO 22GP5 (pino 7)
SDAA4GPIO 21GP4 (pino 6)
ADDRDesconectado ou GND (0x23)Desconectado ou GND (0x23)Desconectado ou GND (0x23)
LED da luz noturna (com 220 Ω)D9GPIO 25GP15 (pino 20)
LEDs do medidor da sala (vermelho, amarelo, verde)D5, D6, D7--
No ESP32 e no Pico, sempre alimente o módulo pelo pino 3V3. Em algumas placas GY-302, os resistores de pull-up do I2C estão ligados diretamente ao VCC; se você alimentar o módulo com 5 V, as linhas SDA e SCL são puxadas para 5 V e podem danificar os pinos dessas placas de 3,3 V. Outro erro comum é inverter SDA e SCL: aí o sensor nunca é encontrado e o scanner I2C retorna uma lista vazia. Se você ligar o pino ADDR em 3,3 V, o endereço passa a ser 0x5C, e assim dá para colocar dois BH1750 no mesmo barramento I2C. Se não souber o endereço, rode o código do scanner do post sobre o LCD I2C.

Modos de medição: qual escolher?

Modo (nome na biblioteca)ComandoResoluçãoTempo de mediçãoQuando usar
CONTINUOUS_HIGH_RES_MODE0x101 lx~120 msUso geral, padrão
CONTINUOUS_HIGH_RES_MODE_20x110,5 lx~120 msAmbientes pouco iluminados, medições noturnas
CONTINUOUS_LOW_RES_MODE0x134 lx~16 msLuz que muda rápido, clarões repentinos
ONE_TIME_HIGH_RES_MODE0x201 lx~120 msProjetos com bateria, dorme após medir
ONE_TIME_HIGH_RES_MODE_20x210,5 lx~120 msMedição com bateria e pouca luz
ONE_TIME_LOW_RES_MODE0x234 lx~16 msMediçã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

  1. 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.
  2. 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.
  3. Carregue o código abaixo e abra o Monitor Serial em 9600 baud.
  4. 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.
  5. 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.
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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}
Coloque o sensor num lugar onde ele não veja a luz da lâmpada. Se o BH1750 enxergar a lâmpada, o ambiente clareia assim que ela acende, o limite de desligamento é ultrapassado, a lâmpada apaga, fica escuro e o ciclo recomeça. Posicionar o sensor voltado para a janela ou para o teto, com a lâmpada atrás dele, elimina esse problema de realimentação. Se não quiser que a sombra de alguém passando acione a lâmpada, use a média das últimas 5–10 leituras.

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.

ÁreaIluminância média recomendada (TS EN 12464-1)
Corredor100 lx
Sala de aula geral (fundamental e médio)300 lx
Sala de informática300 lx
Ginásio300 lx
Aulas noturnas e educação de adultos500 lx
Quadro500 lx
Laboratório500 lx
Área de leitura da biblioteca500 lx
Sala de desenho técnico750 lx
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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

SintomaCausa provávelSolução
“BH1750 not found” (não encontrado), begin() retorna falseSDA e SCL invertidos, endereço errado ou Wire.begin() esquecidoConfira os fios, rode o scanner I2C, ajuste o endereço para 0x23 ou 0x5C
Valor travado em torno de 54.612Saturação sob sol direto (65.535 / 1,2)Amplie a faixa com setMTreg(31)
Valor é -1 ou -2Erro de leitura I2C ou sensor não configuradoConfira o retorno de begin(), encurte os fios
O valor nunca muda depois da primeira leituraO sensor entrou em repouso no modo de medição únicaUse o modo contínuo ou chame configure() antes de cada leitura
As leituras ficam oscilandoSombra, mão, sensor inclinadoFaça uma média, fixe o sensor na horizontal e firme
A luz noturna fica ligando e desligandoLimite único ou o sensor está vendo a lâmpadaAdicione histerese, afaste o sensor da lâmpada
ESP32 ou Pico trava, erro de I2CMódulo alimentado com 5 V ou fios longos demaisAlimente 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.

Ver todos os projetos
Medição da intensidade da luz com LDR
AR-11Iniciante

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.

4.6(83)
143
Luz noturna com LDR
AR-12Iniciante

Luz noturna com LDR

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

4.7(105)
224
Leitura da intensidade da luz com módulo LDR e ESP32
ES-11Iniciante

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.

4.6(36)
55
Luz noturna com LDR e ESP32
ES-10Iniciante
Premium

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.

4.6(17)
30
Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)
ES-37Avançado
Premium

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.

4.3(6)
11
Iluminação inteligente de escadas e corredores
AR-82Intermediário
Premium

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.

5.0(36)
52
Uso do display LCD com I2C
AR-32Iniciante
Premium

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…

4.8(53)
70
Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)
PI-14Iniciante

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.

4