Componenti · 10 min di lettura

Sensore di luce BH1750 Arduino: misurare i lux con I2C e codice

Sensore di luce BH1750 con Arduino: collegamento I2C, modalità di misura, differenza con l'LDR, lampada notturna automatica e luxmetro per aula.

Il BH1750 è un sensore di luce digitale a 16 bit con interfaccia I2C che misura la luce ambientale direttamente in lux (lx). Il collegamento del BH1750 ad Arduino richiede solo quattro fili e, invece di una tensione grezza, il sensore ti restituisce un valore in lux già tarato in fabbrica. Per questo è il modulo preferito quando vuoi davvero misurare la luce, e non solo distinguere "buio o luce": per esempio per sapere se un'aula è abbastanza illuminata o quanta luce riceve una pianta durante la giornata.

In commercio si trova di solito con il nome GY-302, una piccola scheda con regolatore a 3,3 V e resistenze di pull-up I2C. In questo articolo scoprirai come funziona il sensore, a cosa corrispondono i lux nella vita di tutti i giorni, la differenza con l'LDR, le modalità di misura e il collegamento ad Arduino Uno, ESP32 e Raspberry Pi Pico. Poi realizzeremo due applicazioni reali: una lampada notturna automatica protetta contro gli accendi-spegni continui e un luxmetro per aula che dà un giudizio in base ai valori standard.

Che cos'è il BH1750 e come funziona?

Il BH1750 è un sensore di luce ambientale prodotto da ROHM. Al suo interno ci sono un fotodiodo, un amplificatore che trasforma la corrente del fotodiodo in tensione, un convertitore analogico-digitale (ADC) a 16 bit e un'interfaccia I2C. La sensibilità spettrale del fotodiodo è vicina a quella dell'occhio umano, con il picco intorno a 560 nm, cioè nella zona verde-gialla: in questo modo ignora in gran parte l'infrarosso e il valore misurato somiglia alla luminosità percepita dai tuoi occhi. Il sensore è inoltre progettato per eliminare lo sfarfallio di rete a 50/60 Hz, quindi le letture non saltano sotto lampade fluorescenti o LED. Con l'impostazione predefinita, il valore grezzo a 16 bit viene convertito in lux dividendolo per 1,2: se il valore grezzo è 600, la luce ambientale è 600 / 1,2 = 500 lux. La libreria fa questo calcolo al posto tuo.

CaratteristicaValore
ChipROHM BH1750FVI
Campo di misuraCirca 1–54.600 lx con l'impostazione predefinita (grezzo 0–65.535); 0,11–100.000 lx regolando MTreg
Risoluzione0,5 lx, 1 lx o 4 lx (a seconda della modalità)
ADC16 bit
PrecisioneTipica ±20%
Tempo di misuraCirca 120 ms (alta risoluzione), 16 ms (bassa risoluzione)
AlimentazioneChip 2,4–3,6 V; modulo GY-302 3–5 V
CorrenteCirca 120 µA durante la misura, circa 0,01 µA in sleep
InterfacciaI2C, fino a 400 kHz
Indirizzo I2C0x23 (ADDR basso o scollegato), 0x5C (ADDR alto)
PinVCC, GND, SCL, SDA, ADDR

Che cos'è il lux? Valori della vita quotidiana

Il lux è l'unità di misura della quantità di luce che cade su una superficie: 1 lux è un flusso luminoso di 1 lumen su un metro quadrato (1 lx = 1 lm/m²). La cosa importante è che il lux non descrive la lampada in sé, ma la luce che arriva sulla superficie che misuri. La stessa lampada può dare 500 lux sulla scrivania e 120 lux sulla parete a due metri di distanza, perché la luce di una sorgente puntiforme diminuisce con il quadrato della distanza. Il nostro occhio invece lavora in modo logaritmico: passare da 50 a 100 lux si nota molto più che passare da 1000 a 1050 lux. La tabella seguente ti aiuta a interpretare i numeri che leggerai dal sensore.

AmbienteIlluminamento approssimativo
Luna piena in una notte serena0,1–0,3 lx
Lampada notturna, corridoio poco illuminato5–50 lx
Sotto un lampione10–20 lx
Soggiorno di casa50–200 lx
Ufficio, aula300–500 lx
All'aperto con cielo coperto1000–10.000 lx
All'ombra in una giornata di sole10.000–25.000 lx
Luce solare diretta32.000–100.000 lx

Differenza tra BH1750 e LDR

L'LDR (fotoresistenza) è un componente semplice la cui resistenza diminuisce all'aumentare della luce. Si collega a un pin analogico con un partitore di tensione e ti dà un numero tra 0 e 1023, che cambia in base al tipo di LDR, al valore della resistenza in serie, alla tensione di alimentazione e alla temperatura. Quindi due LDR diversi possono mostrare valori diversi nella stessa stanza e, per convertire il valore in lux, devi tarare ciascuno separatamente. Il BH1750 invece è tarato in fabbrica e dà direttamente i lux: con la stessa luce due moduli danno risultati vicini. In compenso l'LDR costa pochissimo, si collega a qualsiasi scheda con un pin analogico ed è ancora sufficiente per i progetti semplici che devono solo rilevare il buio. Un altro svantaggio dell'LDR è la lentezza: nel passaggio dalla luce al buio la sua resistenza può impiegare centinaia di millisecondi, a volte secondi, per stabilizzarsi.

CaratteristicaBH1750LDR
UscitaDigitale, direttamente in luxAnalogica, variazione di resistenza
TaraturaNon necessariaNecessaria per avere i lux
CollegamentoI2C (SDA, SCL)Pin analogico e resistenza in serie
Campo1–54.600 lx (predefinito)Relativo, non lineare
Risposta spettraleVicina all'occhio umanoVaria a seconda del tipo
Più sensori sulla stessa linea2 (0x23 e 0x5C)Un pin analogico per ciascuno
Progetto adattoMisura, registrazione, controllo dell'illuminazioneSemplice rilevamento buio/luce

Collegamento del BH1750: Arduino Uno, ESP32 e Pico

Pin BH1750Arduino UnoESP32Raspberry Pi Pico
VCC5V o 3.3V3V33V3(OUT) (pin 36)
GNDGNDGNDGND (pin 38)
SCLA5GPIO 22GP5 (pin 7)
SDAA4GPIO 21GP4 (pin 6)
ADDRScollegato o GND (0x23)Scollegato o GND (0x23)Scollegato o GND (0x23)
LED della lampada notturna (con 220 Ω)D9GPIO 25GP15 (pin 20)
LED del luxmetro (rosso, giallo, verde)D5, D6, D7--
Su ESP32 e Pico alimenta sempre il modulo dal pin 3V3. Su alcune schede GY-302 le resistenze di pull-up I2C sono collegate direttamente a VCC: se alimenti il modulo a 5 V, le linee SDA e SCL vengono portate a 5 V e possono danneggiare i pin di queste schede che lavorano a 3,3 V. Un altro errore frequente è invertire SDA e SCL: in questo caso il sensore non viene trovato e lo scanner I2C restituisce una lista vuota. Se colleghi il pin ADDR a 3,3 V l'indirizzo diventa 0x5C, così puoi collegare due BH1750 sulla stessa linea I2C. Se non conosci l'indirizzo, esegui il codice dello scanner nell'articolo sul display LCD I2C.

Modalità di misura: quale scegliere?

Modalità (nome nella libreria)ComandoRisoluzioneTempo di misuraQuando usarla
CONTINUOUS_HIGH_RES_MODE0x101 lx~120 msUso generale, predefinita
CONTINUOUS_HIGH_RES_MODE_20x110,5 lx~120 msAmbienti poco illuminati, misure notturne
CONTINUOUS_LOW_RES_MODE0x134 lx~16 msLuce che cambia rapidamente, lampi improvvisi
ONE_TIME_HIGH_RES_MODE0x201 lx~120 msProgetti a batteria, va in sleep dopo la misura
ONE_TIME_HIGH_RES_MODE_20x210,5 lx~120 msMisure a batteria in ambienti poco illuminati
ONE_TIME_LOW_RES_MODE0x234 lx~16 msMisura rapida con il minimo consumo

Nelle modalità continue il sensore continua a misurare da solo e tu leggi l'ultimo risultato quando vuoi. Nelle modalità a singola misura il sensore esegue una misura e poi passa in risparmio energetico; poiché in sleep la corrente scende ben sotto 1 µA, è ideale per i progetti a batteria che per esempio si risvegliano ogni 10 minuti con il deep sleep dell'ESP32. Se vuoi cambiare ancora la sensibilità puoi usare il registro del tempo di misura (MTreg). Il valore predefinito è 69; portarlo a 254 aumenta la sensibilità di circa 3,7 volte e in modalità H2 ti permette di scendere fino a 0,11 lux. Abbassarlo a 31 invece allarga il campo oltre i 100.000 lux e risolve il problema del valore bloccato al massimo sotto il sole diretto. Nella libreria lo fai con setMTreg(valore); più MTreg è alto, più il tempo di misura si allunga, circa 440 ms a 254.

Passo dopo passo: la prima misura in lux con Arduino

  1. Nell'IDE di Arduino apri il Gestore librerie, cerca BH1750 e installa la libreria "BH1750" di Christopher Laws. Se hai problemi con l'installazione, consulta l'articolo su come aggiungere librerie ad Arduino.
  2. Collega VCC del modulo a 5V, GND a GND, SCL ad A5, SDA ad A4; lascia scollegato il pin ADDR. Anche i pin SDA e SCL accanto ad AREF sull'Uno sono la stessa linea di A4 e A5.
  3. Carica il codice qui sotto e apri il Monitor seriale a 9600 baud.
  4. Copri il sensore con la mano, poi puntaci la torcia del telefono: dovresti vedere il valore salire da pochi lux a migliaia di lux.
  5. Se nel Monitor seriale compare "bulunamadi" (non trovato), controlla i cavi e l'indirizzo e verifica con lo scanner I2C che il sensore compaia a 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() avvia la linea I2C, mentre lightMeter.begin() alimenta il sensore, imposta la modalità scelta e restituisce true se tutto va bene. readLightLevel() restituisce l'ultima misura in lux come float; se il valore è negativo (-1 o -2) la lettura è fallita, quindi è buona abitudine controllarlo prima di usarlo nei calcoli. In modalità continua ad alta risoluzione un nuovo risultato è pronto circa ogni 120 ms, perciò far girare il ciclo più velocemente ti fa solo rileggere lo stesso valore. Se vuoi capire come funziona l'I2C, dai un'occhiata all'articolo Che cos'è l'I2C.

Esempio 1: lampada notturna automatica con il BH1750

L'errore più comune nelle lampade notturne è usare una sola soglia. Se scegli 15 lux, quando l'ambiente è intorno a 14–16 lux, per esempio al crepuscolo, la lampada si accende e si spegne più volte al secondo. La soluzione è l'isteresi, cioè due soglie distinte: la lampada si accende quando la luce scende sotto i 10 lux, ma si spegne solo quando supera i 25 lux. Nella zona intermedia di 15 lux la lampada mantiene lo stato attuale. Nel codice seguente usiamo un LED collegato a D9 con una resistenza da 220 Ω; per una lampada vera puoi collegare un modulo relè al posto del LED. Se usi un LED di un altro colore, trova la resistenza giusta con il calcolatore di resistenza per 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}
Metti il sensore in un punto da cui non possa vedere la luce della lampada. Se il BH1750 vede la lampada, nel momento in cui si accende l'ambiente si illumina, la soglia di spegnimento viene superata, la lampada si spegne, l'ambiente torna buio e il ciclo ricomincia. Posizionare il sensore rivolto verso la finestra o il soffitto e la lampada dietro di esso elimina questo problema di retroazione. Se non vuoi che l'ombra di chi ti passa davanti attivi la lampada, usa la media delle ultime 5–10 misure.

Esempio 2: misura dell'illuminazione in un'aula

Nelle scuole e negli uffici, capire se l'illuminazione è sufficiente si fa con la misura, non a occhio. La norma sull'illuminazione degli interni EN 12464-1 (in Italia UNI EN 12464-1) raccomanda per le aule generali almeno 300 lux medi sul piano di lavoro e 500 lux per le classi serali, la formazione degli adulti e la lavagna. Per una misura corretta, appoggia il sensore in orizzontale sul banco, a circa 75–80 cm di altezza, con la superficie sensibile rivolta verso il soffitto, ed evita di proiettarci sopra la tua ombra. Dividi l'aula con una griglia immaginaria; misura separatamente nei banchi davanti, al centro, in fondo e sul lato finestra e su quello corridoio, e annota la media dei risultati e il valore minimo. Poiché la luce naturale cambia molto i valori, ripeti la misura una volta a mezzogiorno con le tende aperte e una volta con le tende chiuse e solo le lampade accese. È anche un ottimo progetto di raccolta dati per una fiera della scienza.

AmbienteIlluminamento medio raccomandato (EN 12464-1)
Corridoio100 lx
Aula generale (scuola primaria e secondaria)300 lx
Aula di informatica300 lx
Palestra300 lx
Classi serali e formazione degli adulti500 lx
Lavagna500 lx
Laboratorio500 lx
Area di lettura della biblioteca500 lx
Aula di disegno tecnico750 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 con ESP32: LED che si attenua in base all'ambiente

Sull'ESP32 funziona la stessa libreria BH1750; l'unica differenza è che indichi esplicitamente i pin I2C con Wire.begin(21, 22). In questo esempio, invece di accendere e spegnere la lampada, regoliamo la luminosità del LED in modo continuo in base alla luce ambientale: a 0 lux il LED è alla massima luminosità, a 200 lux e oltre è completamente spento e nel mezzo si attenua in modo lineare. Sull'ESP32 il segnale PWM è generato dall'unità LEDC, le cui funzioni sono cambiate con l'Arduino core 3.x; il codice è diviso con un controllo ESP_ARDUINO_VERSION_MAJOR in modo da compilare con entrambe le versioni. Puoi trovare la logica del PWM nell'articolo Che cos'è il PWM. Grazie al Wi-Fi dell'ESP32 puoi anche inviare la stessa misura a Home Assistant via MQTT e usarla nell'automazione della casa intelligente.

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 con Raspberry Pi Pico e MicroPython

Su Raspberry Pi Pico con MicroPython non serve nemmeno una libreria aggiuntiva per usare il BH1750: i comandi del sensore sono così semplici che puoi parlare direttamente via I2C. Per prima cosa inviamo il comando 0x01 (accensione), poi 0x10 (alta risoluzione continua). Poi, a ogni lettura, prendiamo 2 byte dal sensore, li uniamo in un unico numero a 16 bit e dividiamo per 1,2. Nell'output di i2c.scan() dovresti vedere il numero 35, che è l'equivalente decimale di 0x23; se ADDR è alto vedrai 92, cioè 0x5C. Il codice implementa la lampada notturna con isteresi dell'esempio Arduino con un LED collegato a GP15. Se sei nuovo di MicroPython, dai prima un'occhiata all'articolo Che cos'è 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)

Idee di progetto con il BH1750

  • Tenda intelligente: in base al valore in lux, apri e chiudi automaticamente una tenda o una persiana con un servomotore.
  • Monitoraggio della luce in serra: misura la luce che le piante ricevono durante il giorno; nel tuo progetto di serra intelligente accendi la lampada di crescita se la luce è insufficiente.
  • Inseguitore solare: con due BH1750 agli indirizzi 0x23 e 0x5C trova la direzione da cui arriva la luce e ruota il pannello del sistema di inseguimento solare verso di essa.
  • Luminosità automatica dello schermo: come sugli smartphone, regola la luminosità di un display OLED in base alla luce ambientale.
  • Esposimetro fotografico: calcola il valore di esposizione per ISO 100 con la formula EV = log2(lux / 2,5) e mostralo sul display.
  • Mappa della luce in aula: salva le misure su Fogli Google e ricava la mappa dell'illuminazione dell'aula; è un ottimo set di dati per un progetto scientifico.

Errori comuni e soluzioni

SintomoCausa probabileSoluzione
"BH1750 bulunamadi", begin() restituisce falseSDA e SCL invertiti, indirizzo sbagliato o Wire.begin() dimenticatoControlla i cavi, esegui lo scanner I2C, imposta l'indirizzo 0x23 o 0x5C
Il valore resta bloccato intorno a 54.612Saturazione sotto il sole diretto (65.535 / 1,2)Allarga il campo di misura con setMTreg(31)
Il valore è -1 o -2Errore di lettura I2C o sensore non configuratoControlla il valore restituito da begin(), accorcia i cavi
Dopo la prima lettura il valore non cambia piùIn modalità a singola misura il sensore è andato in sleepUsa la modalità continua oppure chiama configure() prima di ogni lettura
Le letture oscillano continuamenteOmbra, mano, sensore tenuto inclinatoFai la media, posiziona il sensore in orizzontale e fermo
La lampada notturna si accende e si spegneUna sola soglia o il sensore vede la lampadaAggiungi l'isteresi, allontana il sensore dalla lampada
ESP32 o Pico si blocca, errore I2CModulo alimentato a 5 V o cavi troppo lunghiAlimenta il modulo a 3V3, tieni i cavi sotto i 30 cm

Il BH1750 sostituisce tranquillamente l'LDR in ogni progetto in cui vuoi misurare la luce invece di stimarla: quattro fili, una sola libreria e lux diretti. Se ti basta un semplice rilevamento del buio, l'LDR resta la soluzione più economica; ma se ti servono misura, registrazione o un confronto con una norma, scegli il BH1750. Nell'app BlueGrays trovi passo dopo passo, con schemi elettrici e codice, progetti legati alla luce come la lettura dell'intensità luminosa con LDR e lampada notturna, l'illuminazione intelligente con ESP32 e l'illuminazione intelligente per le scale, e potrai adattare facilmente a questi progetti gli esempi BH1750 di questo articolo.

Domande frequenti

Quanti lux può misurare il BH1750?

Con l'impostazione predefinita il BH1750 misura da circa 1 a 54.600 lux con risoluzione di 1 lux; deriva dalla divisione del valore grezzo a 16 bit (65.535) per 1,2. Se abbassi MTreg a 31, il campo supera i 100.000 lux e puoi misurare la luce solare diretta. Se invece alzi MTreg a 254 e usi la modalità H2, riesci a distinguere la luce debole fino a 0,11 lux.

Qual è l'indirizzo I2C del BH1750?

Se il pin ADDR è scollegato o collegato a GND, l'indirizzo è 0x23; se è collegato a 3,3 V, diventa 0x5C. In questo modo puoi collegare due BH1750 sulla stessa linea I2C. Se ti servono più sensori, devi usare un multiplexer I2C come il TCA9548A.

È meglio il BH1750 o l'LDR?

Per una misura vera il BH1750 è molto meglio: dà direttamente i lux, non richiede taratura e ha una risposta simile a quella dell'occhio umano. L'LDR costa meno ed è sufficiente solo per semplici lampade notturne che devono rilevare l'inizio del buio. Se devi registrare valori o confrontarli con una norma, scegli il BH1750.

Il BH1750 funziona a 5 V?

Il chip BH1750 funziona a 2,4–3,6 V, ma i moduli come il GY-302 hanno un regolatore a 3,3 V, quindi il modulo può essere alimentato a 3–5 V e collegato direttamente ad Arduino Uno. Su ESP32 e Raspberry Pi Pico devi invece alimentare il modulo dal pin 3V3, così anche le linee I2C restano a 3,3 V.

Il BH1750 si può usare al sole e all'aperto?

Sì, ma con l'impostazione predefinita sotto il sole diretto il valore si blocca intorno a 54.600 lux; puoi superarlo con setMTreg(31). Per proteggere il sensore dalla pioggia usa una copertura trasparente, ma ricorda che la copertura assorbe parte della luce e correggi i risultati con un coefficiente. È anche importante non chiudere la scheda in una scatola nera che si scalderebbe al sole.

Perché il valore del BH1750 è diverso da quello di un luxmetro?

La precisione tipica del sensore è ±20% e inoltre l'angolo di incidenza della luce e lo spettro di colore della lampada influenzano il risultato. Metti il sensore nello stesso punto e con lo stesso angolo del luxmetro, confronta con alcune luci diverse e poi aggiungi il rapporto ottenuto nel codice come coefficiente di correzione. Fai anche attenzione a non far cadere la tua ombra sul sensore durante la misura.

Vedi tutti i progetti
Misurare l'intensità luminosa con LDR
AR-11Principiante

Misurare l'intensità luminosa con LDR

Vuoi vedere quanto è luminosa la tua stanza sotto forma di numero? L'LDR, un piccolo componente sensibile alla luce, misura la luce ambiente e l'Arduino scrive il valore sullo schermo del computer…

4.6(83)
143
Luce notturna con LDR
AR-12Principiante

Luce notturna con LDR

Una piccola luce notturna che si accende da sola quando fa buio e si spegne quando arriva il mattino.

4.7(105)
224
Lettura dell'intensità luminosa con il modulo LDR ESP32
ES-11Principiante

Lettura dell'intensità luminosa con il modulo LDR ESP32

Monitoraggio in tempo reale sul Serial Monitor del valore grezzo dell'ADC del modulo LDR e della percentuale relativa di luce calcolata dai valori di riferimento al buio e alla luce. Questa percentuale non è una misurazione in lux. Spiega il principio di calibrazione del modulo. È consigliabile eseguirlo prima del Progetto 10, poiché serve a determinare il valore di soglia.

4.6(36)
55
ESP32 Luce notturna con LDR
ES-10Principiante
Premium

ESP32 Luce notturna con LDR

Luce notturna in cui il LED si accende automaticamente al buio e si spegne alla luce. Viene utilizzato il pin D0 (digital out) del modulo sensore LDR - la soglia di buio viene impostata con il piccolo potenziometro sul modulo, il modulo stesso genera l'uscita HIGH/LOW. ESP32 legge questo segnale con digitalRead(), il codice è molto semplice.

4.6(17)
30
Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
ES-37Avanzato
Premium

Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)

Con un ESP32, un sensore di movimento PIR, un sensore di luce LDR e un modulo relè trasformiamo il corridoio, il bagno o la dispensa di casa in un'illuminazione smart. Se l'ambiente è già luminoso, la luce non si accende nemmeno con il movimento, così di giorno non spreca energia. La luce resta accesa 30 secondi e il tempo si allunga in automatico finché il movimento continua.

4.3(6)
11
Illuminazione intelligente di scale e corridoi
AR-82Intermedio
Premium

Illuminazione intelligente di scale e corridoi

Metti piede sulle scale o nel corridoio e le luci si accendono gradino dopo gradino nella direzione in cui cammini.

5.0(36)
52
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70
Raspberry Pi Pico PWM LED Fade (Effetto Respiro)
PI-14Principiante

Raspberry Pi Pico PWM LED Fade (Effetto Respiro)

Il LED non lampeggia più — respira! Con il PWM (modulazione di larghezza d'impulso) del Raspberry Pi Pico, la luminosità sale e scende lentamente. Impara la classe machine.PWM, duty_u16() (luminosità a 16 bit 0–65535), la frequenza PWM, i cicli range() e l'uscita quasi analogica. Base per miscelazione colori RGB, controllo motori, servo e buzzer.

4