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.
| Caratteristica | Valore |
|---|---|
| Chip | ROHM BH1750FVI |
| Campo di misura | Circa 1–54.600 lx con l'impostazione predefinita (grezzo 0–65.535); 0,11–100.000 lx regolando MTreg |
| Risoluzione | 0,5 lx, 1 lx o 4 lx (a seconda della modalità) |
| ADC | 16 bit |
| Precisione | Tipica ±20% |
| Tempo di misura | Circa 120 ms (alta risoluzione), 16 ms (bassa risoluzione) |
| Alimentazione | Chip 2,4–3,6 V; modulo GY-302 3–5 V |
| Corrente | Circa 120 µA durante la misura, circa 0,01 µA in sleep |
| Interfaccia | I2C, fino a 400 kHz |
| Indirizzo I2C | 0x23 (ADDR basso o scollegato), 0x5C (ADDR alto) |
| Pin | VCC, 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.
| Ambiente | Illuminamento approssimativo |
|---|---|
| Luna piena in una notte serena | 0,1–0,3 lx |
| Lampada notturna, corridoio poco illuminato | 5–50 lx |
| Sotto un lampione | 10–20 lx |
| Soggiorno di casa | 50–200 lx |
| Ufficio, aula | 300–500 lx |
| All'aperto con cielo coperto | 1000–10.000 lx |
| All'ombra in una giornata di sole | 10.000–25.000 lx |
| Luce solare diretta | 32.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.
| Caratteristica | BH1750 | LDR |
|---|---|---|
| Uscita | Digitale, direttamente in lux | Analogica, variazione di resistenza |
| Taratura | Non necessaria | Necessaria per avere i lux |
| Collegamento | I2C (SDA, SCL) | Pin analogico e resistenza in serie |
| Campo | 1–54.600 lx (predefinito) | Relativo, non lineare |
| Risposta spettrale | Vicina all'occhio umano | Varia a seconda del tipo |
| Più sensori sulla stessa linea | 2 (0x23 e 0x5C) | Un pin analogico per ciascuno |
| Progetto adatto | Misura, registrazione, controllo dell'illuminazione | Semplice rilevamento buio/luce |
Collegamento del BH1750: Arduino Uno, ESP32 e Pico
| Pin 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 | Scollegato o GND (0x23) | Scollegato o GND (0x23) | Scollegato o GND (0x23) |
| LED della lampada notturna (con 220 Ω) | D9 | GPIO 25 | GP15 (pin 20) |
| LED del luxmetro (rosso, giallo, verde) | D5, D6, D7 | - | - |
Modalità di misura: quale scegliere?
| Modalità (nome nella libreria) | Comando | Risoluzione | Tempo di misura | Quando usarla |
|---|---|---|---|---|
| CONTINUOUS_HIGH_RES_MODE | 0x10 | 1 lx | ~120 ms | Uso generale, predefinita |
| CONTINUOUS_HIGH_RES_MODE_2 | 0x11 | 0,5 lx | ~120 ms | Ambienti poco illuminati, misure notturne |
| CONTINUOUS_LOW_RES_MODE | 0x13 | 4 lx | ~16 ms | Luce che cambia rapidamente, lampi improvvisi |
| ONE_TIME_HIGH_RES_MODE | 0x20 | 1 lx | ~120 ms | Progetti a batteria, va in sleep dopo la misura |
| ONE_TIME_HIGH_RES_MODE_2 | 0x21 | 0,5 lx | ~120 ms | Misure a batteria in ambienti poco illuminati |
| ONE_TIME_LOW_RES_MODE | 0x23 | 4 lx | ~16 ms | Misura 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
- 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.
- 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.
- Carica il codice qui sotto e apri il Monitor seriale a 9600 baud.
- Copri il sensore con la mano, poi puntaci la torcia del telefono: dovresti vedere il valore salire da pochi lux a migliaia di lux.
- 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.
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.
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}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.
| Ambiente | Illuminamento medio raccomandato (EN 12464-1) |
|---|---|
| Corridoio | 100 lx |
| Aula generale (scuola primaria e secondaria) | 300 lx |
| Aula di informatica | 300 lx |
| Palestra | 300 lx |
| Classi serali e formazione degli adulti | 500 lx |
| Lavagna | 500 lx |
| Laboratorio | 500 lx |
| Area di lettura della biblioteca | 500 lx |
| Aula di disegno tecnico | 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 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.
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.
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
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| "BH1750 bulunamadi", begin() restituisce false | SDA e SCL invertiti, indirizzo sbagliato o Wire.begin() dimenticato | Controlla i cavi, esegui lo scanner I2C, imposta l'indirizzo 0x23 o 0x5C |
| Il valore resta bloccato intorno a 54.612 | Saturazione sotto il sole diretto (65.535 / 1,2) | Allarga il campo di misura con setMTreg(31) |
| Il valore è -1 o -2 | Errore di lettura I2C o sensore non configurato | Controlla 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 sleep | Usa la modalità continua oppure chiama configure() prima di ogni lettura |
| Le letture oscillano continuamente | Ombra, mano, sensore tenuto inclinato | Fai la media, posiziona il sensore in orizzontale e fermo |
| La lampada notturna si accende e si spegne | Una sola soglia o il sensore vede la lampada | Aggiungi l'isteresi, allontana il sensore dalla lampada |
| ESP32 o Pico si blocca, errore I2C | Modulo alimentato a 5 V o cavi troppo lunghi | Alimenta 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.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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…

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

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.

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.

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.

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.

Utilizzo dello schermo LCD con I2C
Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

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.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

