Capteur de lumière BH1750 Arduino : mesurer les lux (guide)
Capteur de lumière BH1750 avec Arduino : mesure en lux, câblage I2C, modes, différence avec la LDR, veilleuse automatique et mesure d'éclairage de classe.
Le BH1750 est un capteur de lumière numérique 16 bits, communiquant en I2C, qui mesure la lumière ambiante directement en lux (lx). Le branchement d'un BH1750 sur Arduino ne demande que quatre fils, et le capteur te donne une valeur en lux étalonnée en usine plutôt qu'une tension brute. Quand tu veux vraiment mesurer la lumière au lieu de simplement distinguer « sombre » et « clair », par exemple savoir si une salle de classe est assez éclairée ou combien de lumière une plante reçoit dans la journée, c'est le module à choisir en premier.
On le trouve généralement sous le nom de GY-302, une petite carte avec régulateur 3,3 V et résistances de pull-up I2C. Dans cet article, tu vas voir comment fonctionne le capteur, à quoi correspondent les lux dans la vie de tous les jours, la différence avec une LDR, les modes de mesure et le branchement sur Arduino Uno, ESP32 et Raspberry Pi Pico. Ensuite, on réalisera deux applications concrètes : une veilleuse automatique protégée contre les allumages et extinctions intempestifs, et un luxmètre de classe qui note l'éclairage selon les normes.
Qu'est-ce que le BH1750 et comment fonctionne-t-il ?
Le BH1750 est un capteur de lumière ambiante fabriqué par ROHM. Il contient une photodiode, un amplificateur qui convertit le courant de la photodiode en tension, un convertisseur analogique-numérique (CAN) 16 bits et une interface I2C. La sensibilité spectrale de la photodiode est proche de celle de l'œil humain, avec un maximum vers 560 nm, dans le jaune-vert ; il ignore donc en grande partie l'infrarouge et la valeur mesurée ressemble à la luminosité que perçoit ton œil. Le capteur est aussi conçu pour atténuer le scintillement du secteur 50/60 Hz, de sorte que les valeurs ne sautent pas sous des lampes fluorescentes ou LED. Avec le réglage par défaut, la valeur brute 16 bits est divisée par 1,2 pour obtenir des lux : si la valeur brute est 600, la lumière ambiante est de 600 / 1,2 = 500 lux. La bibliothèque fait ce calcul pour toi.
| Caractéristique | Valeur |
|---|---|
| Puce | ROHM BH1750FVI |
| Plage de mesure | Environ 1–54 600 lx par défaut (brut 0–65 535) ; 0,11–100 000 lx avec le réglage MTreg |
| Résolution | 0,5 lx, 1 lx ou 4 lx (selon le mode) |
| CAN | 16 bits |
| Précision | Typiquement ±20 % |
| Temps de mesure | Environ 120 ms (haute résolution), 16 ms (basse résolution) |
| Alimentation | Puce 2,4–3,6 V ; module GY-302 3–5 V |
| Courant | Environ 120 µA en mesure, environ 0,01 µA en veille |
| Interface | I2C, jusqu'à 400 kHz |
| Adresse I2C | 0x23 (ADDR au niveau bas ou libre), 0x5C (ADDR au niveau haut) |
| Broches | VCC, GND, SCL, SDA, ADDR |
Qu'est-ce qu'un lux ? Des valeurs de la vie courante
Le lux est l'unité de la quantité de lumière reçue par une surface : 1 lux correspond à un flux lumineux de 1 lumen sur un mètre carré (1 lx = 1 lm/m²). L'important, c'est que le lux décrit la lumière qui arrive sur la surface que tu mesures, pas la lampe elle-même. La même lampe peut donner 500 lux sur le bureau et 120 lux sur un mur situé deux mètres plus loin, car la lumière d'une source ponctuelle diminue avec le carré de la distance. Ton œil, lui, fonctionne de façon logarithmique : passer de 50 à 100 lux se remarque bien plus que passer de 1000 à 1050 lux. Le tableau ci-dessous t'aide à interpréter les chiffres lus sur le capteur.
| Environnement | Éclairement approximatif |
|---|---|
| Pleine lune par nuit dégagée | 0,1–0,3 lx |
| Veilleuse, couloir sombre | 5–50 lx |
| Sous un lampadaire | 10–20 lx |
| Salon à la maison | 50–200 lx |
| Bureau, salle de classe | 300–500 lx |
| Extérieur par temps couvert | 1000–10 000 lx |
| Ombre par temps ensoleillé | 10 000–25 000 lx |
| Soleil direct | 32 000–100 000 lx |
Différence entre le BH1750 et la LDR
La LDR (photorésistance) est un composant simple dont la résistance diminue quand la lumière augmente. On la branche à une broche analogique avec un pont diviseur et elle te donne un nombre entre 0 et 1023 ; ce nombre dépend du type de LDR, de la valeur de la résistance en série, de la tension d'alimentation et de la température. Deux LDR différentes peuvent donc afficher des valeurs différentes dans la même pièce, et il faut étalonner chacune séparément pour convertir en lux. Le BH1750, lui, est étalonné en usine et donne directement des lux : deux modules donnent des résultats proches sous la même lumière. En contrepartie, la LDR coûte très peu, se branche sur toute carte avec une broche analogique et reste suffisante pour les projets simples qui doivent seulement détecter l'obscurité. Autre inconvénient de la LDR : sa lenteur, car sa résistance peut mettre des centaines de millisecondes, voire des secondes, à se stabiliser en passant de la lumière à l'obscurité.
| Caractéristique | BH1750 | LDR |
|---|---|---|
| Sortie | Numérique, directement en lux | Analogique, variation de résistance |
| Étalonnage | Inutile | Nécessaire pour avoir des lux |
| Connexion | I2C (SDA, SCL) | Broche analogique et résistance en série |
| Plage | 1–54 600 lx (par défaut) | Relative, non linéaire |
| Réponse spectrale | Proche de l'œil humain | Variable selon le type |
| Plusieurs sur le même bus | 2 (0x23 et 0x5C) | Une broche analogique chacune |
| Projet adapté | Mesure, enregistrement, contrôle d'éclairage | Détection simple jour/nuit |
Branchement du BH1750 : Arduino Uno, ESP32 et Pico
| Broche BH1750 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V ou 3.3V | 3V3 | 3V3(OUT) (broche 36) |
| GND | GND | GND | GND (broche 38) |
| SCL | A5 | GPIO 22 | GP5 (broche 7) |
| SDA | A4 | GPIO 21 | GP4 (broche 6) |
| ADDR | Libre ou GND (0x23) | Libre ou GND (0x23) | Libre ou GND (0x23) |
| LED de la veilleuse (avec 220 Ω) | D9 | GPIO 25 | GP15 (broche 20) |
| LED du luxmètre de classe (rouge, jaune, verte) | D5, D6, D7 | - | - |
Modes de mesure : lequel choisir ?
| Mode (nom dans la bibliothèque) | Commande | Résolution | Temps de mesure | Quand l'utiliser ? |
|---|---|---|---|---|
| CONTINUOUS_HIGH_RES_MODE | 0x10 | 1 lx | ~120 ms | Usage général, par défaut |
| CONTINUOUS_HIGH_RES_MODE_2 | 0x11 | 0,5 lx | ~120 ms | Environnements sombres, mesure de nuit |
| CONTINUOUS_LOW_RES_MODE | 0x13 | 4 lx | ~16 ms | Lumière qui change vite, éclairs soudains |
| ONE_TIME_HIGH_RES_MODE | 0x20 | 1 lx | ~120 ms | Projets sur batterie, veille après la mesure |
| ONE_TIME_HIGH_RES_MODE_2 | 0x21 | 0,5 lx | ~120 ms | Sur batterie et en lumière faible |
| ONE_TIME_LOW_RES_MODE | 0x23 | 4 lx | ~16 ms | Mesure rapide avec le moins d'énergie |
En modes continus, le capteur continue de mesurer tout seul et tu lis le dernier résultat quand tu veux. En modes ponctuels, il fait une mesure puis passe en économie d'énergie ; comme son courant en veille tombe très en dessous de 1 µA, c'est idéal pour les projets sur batterie qui se réveillent par exemple toutes les 10 minutes avec l'ESP32 deep sleep. Pour modifier encore la sensibilité, tu peux utiliser le registre de temps de mesure (MTreg). La valeur par défaut est 69 ; la passer à 254 augmente la sensibilité d'environ 3,7 fois et te permet de descendre jusqu'à 0,11 lux en mode H2. La baisser à 31 étend la plage au-delà de 100 000 lux et règle le problème de la valeur bloquée au plafond en plein soleil. Dans la bibliothèque, tu le fais avec setMTreg(valeur) ; plus MTreg est grand, plus le temps de mesure s'allonge, jusqu'à environ 440 ms à 254.
Pas à pas : ta première mesure en lux avec Arduino
- Dans l'IDE Arduino, ouvre le Gestionnaire de bibliothèques, tape BH1750 et installe la bibliothèque « BH1750 » de Christopher Laws. Si tu bloques à l'installation, consulte l'article ajouter une bibliothèque Arduino.
- Relie VCC du module à 5V, GND à GND, SCL à A5 et SDA à A4 ; laisse la broche ADDR libre. Les broches SDA et SCL à côté d'AREF sur l'Uno sont la même ligne que A4 et A5.
- Téléverse le code ci-dessous et ouvre le Moniteur série à 9600 bauds.
- Couvre le capteur avec la main, puis approche la lampe de ton téléphone : tu devrais voir la valeur passer de quelques lux à plusieurs milliers.
- Si le Moniteur série affiche « bulunamadi » (introuvable), vérifie les fils et l'adresse, et assure-toi avec un scanner I2C que le capteur apparaît à 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() démarre le bus I2C, et lightMeter.begin() alimente le capteur, règle le mode choisi et renvoie true en cas de succès. readLightLevel() renvoie la dernière mesure en lux sous forme de float ; si la valeur est négative (-1 ou -2), la lecture a échoué, donc c'est une bonne habitude de la vérifier avant de l'utiliser dans un calcul. En mode continu haute résolution, un nouveau résultat est prêt environ toutes les 120 ms ; faire tourner la boucle plus vite ne te fait que relire la même valeur. Si tu veux comprendre comment fonctionne l'I2C, jette un œil à l'article qu'est-ce que l'I2C.
Exemple 1 : veilleuse automatique avec le BH1750
L'erreur la plus courante sur une veilleuse est d'utiliser un seul seuil. Si tu choisis 15 lux, quand l'ambiance est autour de 14–16 lux, par exemple au crépuscule, la lampe s'allume et s'éteint plusieurs fois par seconde. La solution, c'est l'hystérésis, c'est-à-dire deux seuils distincts : la lampe s'allume quand la lumière passe sous 10 lux, mais ne s'éteint que lorsqu'elle dépasse 25 lux. Dans la zone intermédiaire de 15 lux, la lampe garde son état. Dans le code ci-dessous, on utilise une LED reliée à D9 avec une résistance de 220 Ω ; pour une vraie lampe, tu peux brancher un module relais à la place de la LED. Si tu utilises une LED d'une autre couleur, trouve la bonne résistance avec le calculateur de résistance de 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}Exemple 2 : mesurer l'éclairage d'une salle de classe
Dans les écoles et les bureaux, on sait si l'éclairage est suffisant par la mesure, pas par estimation. La norme d'éclairage intérieur TS EN 12464-1, également utilisée en Turquie (équivalent de l'EN 12464-1), recommande en moyenne au moins 300 lux sur le plan de travail pour les salles de classe générales, et 500 lux pour les cours du soir, la formation des adultes et le tableau. Pour une bonne mesure, place le capteur à plat sur la table, à environ 75–80 cm de hauteur, face sensible vers le plafond, et évite de projeter ton ombre dessus. Divise la classe en une grille imaginaire ; mesure séparément aux tables de devant, du milieu, du fond et côté fenêtre et côté couloir, puis note la moyenne et la valeur la plus basse. Comme la lumière du jour fait beaucoup varier les valeurs, refais la mesure une fois à midi rideaux ouverts, puis une fois rideaux fermés avec seulement les lampes allumées. C'est aussi un excellent projet de collecte de données pour un salon des sciences ou le TÜBİTAK.
| Zone | Éclairement moyen recommandé (TS EN 12464-1) |
|---|---|
| Couloir | 100 lx |
| Salle de classe générale (primaire et secondaire) | 300 lx |
| Salle informatique | 300 lx |
| Gymnase | 300 lx |
| Cours du soir et formation des adultes | 500 lx |
| Tableau | 500 lx |
| Laboratoire | 500 lx |
| Zone de lecture de bibliothèque | 500 lx |
| Salle de dessin technique | 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 avec l'ESP32 : une LED qui s'atténue selon la lumière
Sur ESP32, la même bibliothèque BH1750 fonctionne ; la seule différence est que tu indiques explicitement les broches I2C avec Wire.begin(21, 22). Dans cet exemple, au lieu d'allumer et d'éteindre la lampe, on règle la luminosité de la LED en continu selon la lumière ambiante : à 0 lux la LED est à pleine luminosité, à 200 lux et au-delà elle est complètement éteinte, et entre les deux elle diminue linéairement. Sur l'ESP32, le signal PWM est généré par l'unité LEDC, dont les fonctions ont changé avec Arduino core 3.x ; le code est séparé par un test ESP_ARDUINO_VERSION_MAJOR pour compiler avec les deux versions. Tu trouveras la logique du PWM dans l'article qu'est-ce que le PWM. Grâce au Wi-Fi de l'ESP32, tu peux aussi envoyer la même mesure en MQTT vers Home Assistant et l'utiliser dans tes automatisations de maison connectée.
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 avec Raspberry Pi Pico et MicroPython
Sur le Raspberry Pi Pico, pour utiliser le BH1750 avec MicroPython, tu n'as même pas besoin d'une bibliothèque supplémentaire ; les commandes du capteur sont si simples que tu peux parler directement en I2C. On envoie d'abord 0x01 (mise sous tension), puis 0x10 (mode continu haute résolution). Ensuite, à chaque lecture, on récupère 2 octets du capteur, on les assemble en un seul nombre de 16 bits et on divise par 1,2. Dans la sortie de i2c.scan(), tu dois voir le nombre 35, qui est l'équivalent décimal de 0x23 en hexadécimal ; si ADDR est au niveau haut, tu verras 92, soit 0x5C. Le code applique la veilleuse à hystérésis de l'exemple Arduino avec une LED reliée à GP15. Si MicroPython est nouveau pour toi, consulte d'abord l'article qu'est-ce que le 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)Idées de projets avec le BH1750
- Rideau intelligent : ouvre et ferme automatiquement un rideau ou un store avec un servomoteur selon la valeur en lux.
- Suivi de lumière en serre : mesure la lumière reçue par les plantes dans la journée ; dans ton projet de serre intelligente, allume la lampe de croissance si la lumière est insuffisante.
- Suiveur solaire : avec deux BH1750 aux adresses 0x23 et 0x5C, trouve la direction d'où vient la lumière et oriente le panneau d'un système de suivi solaire dans cette direction.
- Luminosité d'écran automatique : comme sur les téléphones, règle la luminosité d'un écran OLED selon la lumière ambiante.
- Posemètre photo : calcule la valeur d'exposition pour ISO 100 avec la formule EV = log2(lux / 2,5) et affiche-la à l'écran.
- Carte de lumière de classe : enregistre les mesures dans Google Sheets et dresse la carte d'éclairage de la classe ; ce sera un excellent jeu de données pour un projet TÜBİTAK.
Erreurs fréquentes et solutions
| Symptôme | Cause possible | Solution |
|---|---|---|
| « BH1750 bulunamadi », begin() renvoie false | SDA et SCL inversés, mauvaise adresse ou Wire.begin() oublié | Vérifie les fils, lance un scanner I2C, mets l'adresse à 0x23 ou 0x5C |
| La valeur reste bloquée vers 54 612 | Saturation en plein soleil (65 535 / 1,2) | Élargis la plage avec setMTreg(31) |
| Valeur -1 ou -2 | Erreur de lecture I2C ou capteur non configuré | Vérifie le retour de begin(), raccourcis les fils |
| La valeur ne change plus après la première lecture | En mode ponctuel, le capteur s'est mis en veille | Utilise le mode continu ou appelle configure() avant chaque lecture |
| Les mesures fluctuent sans cesse | Ombre, main, capteur tenu de travers | Fais une moyenne, place le capteur à plat et fixe |
| La veilleuse s'allume et s'éteint en boucle | Un seul seuil ou le capteur voit la lampe | Ajoute l'hystérésis, éloigne le capteur de la lampe |
| L'ESP32 ou le Pico se bloque, erreur I2C | Module alimenté en 5 V ou fils trop longs | Alimente le module en 3V3, garde les fils sous 30 cm |
Le BH1750 remplace sans problème la LDR dans tous les projets où tu veux mesurer la lumière au lieu de la deviner : quatre fils, une bibliothèque et des lux directement. Si une simple détection d'obscurité suffit, la LDR reste la solution la moins chère ; mais si tu as besoin de mesurer, d'enregistrer ou de comparer à une norme, choisis le BH1750. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et codes, des projets autour de la lumière comme la lecture de l'intensité lumineuse avec une LDR et la veilleuse, l'éclairage intelligent ESP32 et l'éclairage d'escalier intelligent, et tu pourras facilement y adapter les exemples BH1750 de cet article.
Questions fréquentes
Combien de lux le BH1750 peut-il mesurer ?
Avec le réglage par défaut, le BH1750 mesure d'environ 1 à 54 600 lux avec une résolution de 1 lux ; cela vient de la division de la valeur brute 16 bits (65 535) par 1,2. Si tu descends MTreg à 31, la plage dépasse 100 000 lux et permet de mesurer la lumière directe du soleil. Si tu montes MTreg à 254 et utilises le mode H2, tu distingues une lumière faible jusqu'à 0,11 lux.
Quelle est l'adresse I2C du BH1750 ?
Quand la broche ADDR est laissée libre ou reliée à GND, l'adresse est 0x23 ; reliée à 3,3 V, elle devient 0x5C. Tu peux ainsi brancher deux BH1750 sur le même bus I2C. S'il te faut plus de capteurs, utilise un multiplexeur I2C comme le TCA9548A.
BH1750 ou LDR : lequel est le meilleur ?
Pour une vraie mesure, le BH1750 est bien meilleur : il donne directement des lux, ne demande aucun étalonnage et réagit comme l'œil humain. La LDR est moins chère et suffit seulement pour des veilleuses simples qui doivent détecter la tombée de la nuit. Si tu dois enregistrer des valeurs ou comparer à une norme, choisis le BH1750.
Le BH1750 fonctionne-t-il en 5 V ?
La puce BH1750 fonctionne en 2,4–3,6 V, mais comme les modules comme le GY-302 ont un régulateur 3,3 V, le module peut être alimenté en 3–5 V et branché directement sur un Arduino Uno. Sur ESP32 et Raspberry Pi Pico, alimente le module par la broche 3V3 ; ainsi les lignes I2C restent aussi à 3,3 V.
Peut-on utiliser le BH1750 au soleil et en extérieur ?
Oui, mais avec le réglage par défaut la valeur se bloque vers 54 600 lux en plein soleil ; tu peux dépasser cette limite avec setMTreg(31). Pour protéger le capteur de la pluie, utilise un couvercle transparent, mais n'oublie pas qu'il absorbera une partie de la lumière : corrige alors les résultats avec un coefficient. Évite aussi d'enfermer la carte dans un boîtier noir où elle chaufferait directement.
Pourquoi la valeur du BH1750 diffère-t-elle de celle d'un luxmètre ?
La précision typique du capteur est de ±20 %, et l'angle d'arrivée de la lumière ainsi que le spectre de couleur de la lampe influencent le résultat. Place le capteur au même endroit et sous le même angle que le luxmètre, compare sous plusieurs lumières différentes, puis ajoute le rapport obtenu comme coefficient de correction dans ton code. Veille aussi à ce que ton ombre ne tombe pas sur le capteur pendant la mesure.
Projets à réaliser après cet article
Voir tous les projets
Mesurer l'intensité lumineuse avec une LDR
Envie de voir en chiffres à quel point ta chambre est lumineuse ? Le LDR, une petite pièce sensible à la lumière, mesure la lumière ambiante, et l'Arduino écrit la valeur sur l'écran de ton…

Veilleuse avec LDR
Une petite veilleuse qui s'allume toute seule quand il fait nuit et s'éteint au matin.

Mesure de l'intensité lumineuse avec le module LDR ESP32
Suivi en temps réel sur le moniteur série de la valeur brute de l'ADC du module LDR et du pourcentage relatif de luminosité calculé à partir de références dans l'obscurité et à la lumière. Ce pourcentage n'est pas une mesure en lux. Permet de comprendre le principe de calibrage du module. Il est préférable de réaliser cet exercice avant le projet 10, car il sert à déterminer la valeur seuil.

Veilleuse ESP32 avec LDR
Veilleuse dans laquelle la LED s'allume automatiquement dans l'obscurité et s'éteint à la lumière. La broche D0 (sortie numérique) du module capteur LDR est utilisée - le seuil d'obscurité est réglé avec le petit potentiomètre sur le module, le module lui-même génère la sortie HAUT/BAS. L'ESP32 lit simplement ce signal avec digitalRead(), le code est très simple.

Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)
Avec un ESP32, un capteur de mouvement PIR, un capteur de lumière LDR et un module relais, on transforme ton couloir, tes toilettes ou ton cellier en éclairage intelligent. Si la pièce est déjà claire, la lumière reste éteinte malgré le mouvement : pas de gaspillage d'énergie en journée. La lumière reste allumée 30 secondes et la durée se prolonge automatiquement tant que le mouvement continue.

Éclairage intelligent des escaliers et des couloirs
Pose le pied dans l'escalier ou le couloir et les lumières s'allument marche après marche dans ton sens de passage.

Utilisation de l'écran LCD avec I2C
Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…

Raspberry Pi Pico PWM LED Fade (Effet Respiration)
La LED ne clignote plus — elle respire ! Grâce au PWM (modulation de largeur d'impulsion) du Raspberry Pi Pico, la luminosité monte puis descend lentement. Apprends la classe machine.PWM, duty_u16() (luminosité 16 bits 0–65535), la fréquence PWM, les boucles range() et la sortie quasi analogique. Base du mélange de couleurs RGB, du contrôle moteur, des servos et du buzzer.
Autres articles
- Qu'est-ce qu'un capteur de lumière LDR ? Mesurer la lumière avec Arduino et veilleuse automatique
- Qu'est-ce que l'I2C ? SDA, SCL, résistances pull-up et scanner
- Utiliser un écran OLED (SSD1306) : texte, formes et graphiques avec Arduino
- Qu'est-ce que le PWM ? Guide d'analogWrite, du rapport cyclique et de la fréquence sur Arduino
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

