BH1750 Arduino: Lichtsensor für Lux-Messung anschließen
BH1750 mit Arduino: I2C-Anschluss, Messmodi, Unterschied zum LDR, automatisches Nachtlicht und Klassenzimmer-Lichtmessung inkl. Code für Uno, ESP32, Pico.
Der BH1750 ist ein digitaler 16-Bit-Lichtsensor mit I2C-Schnittstelle, der die Helligkeit direkt in Lux (lx) misst. Den BH1750 an den Arduino anzuschließen geht mit nur vier Kabeln, und statt einer rohen Spannung bekommst du einen werkskalibrierten, aussagekräftigen Luxwert. Wenn du Licht wirklich messen willst, statt nur zwischen "dunkel" und "hell" zu unterscheiden, zum Beispiel um zu prüfen, ob ein Klassenzimmer hell genug ist oder wie viel Licht eine Pflanze am Tag bekommt, ist er das Modul der ersten Wahl.
Du findest ihn meist als GY-302: eine kleine Platine mit 3,3-V-Spannungsregler und I2C-Pull-up-Widerständen. In diesem Beitrag lernst du, wie der Sensor funktioniert, was Lux im Alltag bedeutet, wie er sich vom LDR unterscheidet, welche Messmodi es gibt und wie du ihn an Arduino Uno, ESP32 und Raspberry Pi Pico anschließt. Danach bauen wir zwei echte Anwendungen: ein automatisches Nachtlicht mit Schutz gegen Flackern und ein Lux-Messgerät fürs Klassenzimmer, das nach Normwerten bewertet.
Was ist der BH1750 und wie funktioniert er?
Der BH1750 ist ein Umgebungslichtsensor von ROHM. Er enthält eine Fotodiode, einen Verstärker, der den Fotodiodenstrom in eine Spannung umwandelt, einen 16-Bit-Analog-Digital-Wandler (ADC) und die I2C-Schnittstelle. Die spektrale Empfindlichkeit der Fotodiode entspricht ungefähr der des menschlichen Auges und liegt bei etwa 560 nm im grün-gelben Bereich am höchsten; Infrarotlicht wird dadurch weitgehend ignoriert, und der Messwert passt zur wahrgenommenen Helligkeit. Außerdem unterdrückt der Sensor das 50/60-Hz-Flackern des Stromnetzes, sodass die Werte unter Leuchtstoff- oder LED-Lampen nicht springen. Die 16-Bit-Rohzahl wird in der Standardeinstellung durch 1,2 geteilt, um Lux zu erhalten: Bei einem Rohwert von 600 sind es 600 / 1,2 = 500 Lux. Die Bibliothek rechnet das für dich.
| Eigenschaft | Wert |
|---|---|
| Chip | ROHM BH1750FVI |
| Messbereich | Standardmäßig ca. 1–54.600 lx (roh 0–65.535); mit MTreg 0,11–100.000 lx |
| Auflösung | 0,5 lx, 1 lx oder 4 lx (je nach Modus) |
| ADC | 16 Bit |
| Genauigkeit | Typisch ±20 % |
| Messdauer | Ca. 120 ms (hohe Auflösung), 16 ms (niedrige Auflösung) |
| Versorgung | Chip 2,4–3,6 V; GY-302-Modul 3–5 V |
| Strom | Ca. 120 µA beim Messen, ca. 0,01 µA im Schlafmodus |
| Schnittstelle | I2C, bis 400 kHz |
| I2C-Adresse | 0x23 (ADDR low oder offen), 0x5C (ADDR high) |
| Pins | VCC, GND, SCL, SDA, ADDR |
Was ist Lux? Werte aus dem Alltag
Lux ist die Einheit für die Lichtmenge, die auf eine Fläche fällt: 1 Lux ist ein Lichtstrom von 1 Lumen pro Quadratmeter (1 lx = 1 lm/m²). Wichtig ist, dass Lux nicht die Lampe selbst beschreibt, sondern das Licht, das die gemessene Fläche erreicht. Dieselbe Lampe kann auf dem Tisch 500 Lux liefern und an der zwei Meter entfernten Wand nur 120 Lux, denn das Licht einer punktförmigen Quelle nimmt mit dem Quadrat der Entfernung ab. Unser Auge arbeitet zudem logarithmisch: Der Sprung von 50 auf 100 Lux wirkt viel deutlicher als der von 1000 auf 1050 Lux. Die folgende Tabelle hilft dir, die Messwerte einzuordnen.
| Umgebung | Ungefähre Beleuchtungsstärke |
|---|---|
| Vollmond bei wolkenloser Nacht | 0,1–0,3 lx |
| Nachtlicht, schwach beleuchteter Flur | 5–50 lx |
| Unter einer Straßenlaterne | 10–20 lx |
| Wohnzimmer | 50–200 lx |
| Büro, Klassenzimmer | 300–500 lx |
| Draußen bei bedecktem Himmel | 1000–10.000 lx |
| Schatten an einem sonnigen Tag | 10.000–25.000 lx |
| Direktes Sonnenlicht | 32.000–100.000 lx |
BH1750 oder LDR: der Unterschied
Ein LDR (Fotowiderstand) ist ein einfaches Bauteil, dessen Widerstand mit steigender Helligkeit sinkt. Über einen Spannungsteiler an einem Analogpin liefert er eine Zahl von 0 bis 1023, die vom LDR-Typ, vom Vorwiderstand, von der Versorgungsspannung und von der Temperatur abhängt. Zwei verschiedene LDRs können im selben Raum also unterschiedliche Werte zeigen, und für eine Umrechnung in Lux musst du jeden einzeln kalibrieren. Der BH1750 ist dagegen werkskalibriert und liefert direkt Lux: Zwei Module zeigen bei gleichem Licht ähnliche Ergebnisse. Dafür ist der LDR sehr günstig, passt an jedes Board mit Analogpin und reicht für einfache Projekte, die nur Dunkelheit erkennen sollen. Ein Nachteil des LDR ist seine Trägheit: Beim Wechsel von hell zu dunkel kann es hunderte Millisekunden oder sogar Sekunden dauern, bis sich der Widerstand einpendelt.
| Eigenschaft | BH1750 | LDR |
|---|---|---|
| Ausgang | Digital, direkt in Lux | Analog, Widerstandsänderung |
| Kalibrierung | Nicht nötig | Für Lux nötig |
| Anschluss | I2C (SDA, SCL) | Analogpin und Vorwiderstand |
| Bereich | 1–54.600 lx (Standard) | Relativ, nicht linear |
| Spektrale Empfindlichkeit | Nah am menschlichen Auge | Je nach Typ unterschiedlich |
| Mehrere am selben Bus | 2 Stück (0x23 und 0x5C) | Je ein eigener Analogpin |
| Geeignetes Projekt | Messung, Datenlogger, Lichtsteuerung | Einfache Hell-/Dunkel-Erkennung |
BH1750 anschließen: Arduino Uno, ESP32 und Pico
| BH1750-Pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V oder 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 | Offen oder GND (0x23) | Offen oder GND (0x23) | Offen oder GND (0x23) |
| Nachtlicht-LED (mit 220 Ω) | D9 | GPIO 25 | GP15 (Pin 20) |
| LEDs des Klassenzimmer-Messgeräts (rot, gelb, grün) | D5, D6, D7 | - | - |
Messmodi: Welchen Modus solltest du wählen?
| Modus (Name in der Bibliothek) | Befehl | Auflösung | Messdauer | Wann? |
|---|---|---|---|---|
| CONTINUOUS_HIGH_RES_MODE | 0x10 | 1 lx | ~120 ms | Allgemeine Nutzung, Standard |
| CONTINUOUS_HIGH_RES_MODE_2 | 0x11 | 0,5 lx | ~120 ms | Dämmerlicht, Messung bei Nacht |
| CONTINUOUS_LOW_RES_MODE | 0x13 | 4 lx | ~16 ms | Schnell wechselndes Licht, plötzliche Blitze |
| ONE_TIME_HIGH_RES_MODE | 0x20 | 1 lx | ~120 ms | Batterieprojekte, schläft nach der Messung |
| ONE_TIME_HIGH_RES_MODE_2 | 0x21 | 0,5 lx | ~120 ms | Batteriebetrieb und Messung bei wenig Licht |
| ONE_TIME_LOW_RES_MODE | 0x23 | 4 lx | ~16 ms | Schnelle Messung bei geringstem Energieverbrauch |
In den kontinuierlichen Modi misst der Sensor selbstständig weiter, und du liest das letzte Ergebnis, wann du willst. In den Einzelmessungsmodi misst der Sensor einmal und geht danach in den Stromsparmodus; weil der Strom im Schlaf weit unter 1 µA fällt, ist das ideal für Batterieprojekte, die zum Beispiel per ESP32 Deep Sleep alle 10 Minuten aufwachen. Willst du die Empfindlichkeit weiter verändern, kannst du das Messzeitregister (MTreg) nutzen. Der Standardwert ist 69; 254 erhöht die Empfindlichkeit um etwa das 3,7-Fache und ermöglicht im H2-Modus Messungen bis hinunter zu 0,11 Lux. Ein Wert von 31 erweitert den Messbereich über 100.000 Lux hinaus und löst das Problem, dass der Wert in direkter Sonne am Maximum hängen bleibt. In der Bibliothek stellst du das mit setMTreg(Wert) ein; je größer MTreg, desto länger die Messdauer, bei 254 etwa 440 ms.
Schritt für Schritt: Deine erste Lux-Messung mit Arduino
- Öffne in der Arduino IDE den Bibliotheksverwalter, suche nach BH1750 und installiere die Bibliothek "BH1750" von Christopher Laws. Wenn es bei der Installation hakt, hilft dir der Beitrag Arduino-Bibliothek hinzufügen.
- Verbinde VCC des Moduls mit 5V, GND mit GND, SCL mit A5 und SDA mit A4; lass ADDR offen. Die SDA- und SCL-Pins neben AREF am Uno sind dieselben Leitungen wie A4 und A5.
- Lade den folgenden Code hoch und öffne den Seriellen Monitor mit 9600 Baud.
- Decke den Sensor mit der Hand ab und halte ihn dann an die Taschenlampe deines Handys: Der Wert sollte von wenigen Lux auf mehrere tausend Lux springen.
- Steht im Seriellen Monitor "bulunamadi" (nicht gefunden), prüfe Kabel und Adresse und stelle mit einem I2C-Scanner sicher, dass der Sensor unter 0x23 erscheint.
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() startet den I2C-Bus, lightMeter.begin() versorgt den Sensor mit Strom, stellt den gewählten Modus ein und gibt bei Erfolg true zurück. readLightLevel() liefert die letzte Messung als float in Lux; ist der Wert negativ (-1 oder -2), ist das Lesen fehlgeschlagen, deshalb solltest du ihn prüfen, bevor du damit rechnest. Im kontinuierlichen Modus mit hoher Auflösung ist etwa alle 120 ms ein neues Ergebnis fertig; läuft die Schleife schneller, liest du nur denselben Wert erneut. Wie I2C funktioniert, erfährst du im Beitrag Was ist I2C?.
Beispiel 1: Automatisches Nachtlicht mit dem BH1750
Der häufigste Fehler bei einem Nachtlicht ist ein einzelner Schwellenwert. Wählst du 15 Lux, schaltet die Lampe bei Werten um 14–16 Lux, etwa in der Abenddämmerung, mehrmals pro Sekunde ein und aus. Die Lösung ist eine Hysterese, also zwei getrennte Schwellen: Fällt das Licht unter 10 Lux, geht die Lampe an, und erst über 25 Lux geht sie wieder aus. Im Bereich dazwischen behält die Lampe ihren Zustand. Im Code unten nutzen wir eine LED an D9 mit 220-Ω-Widerstand; für eine echte Lampe kannst du statt der LED ein Relaismodul anschließen. Verwendest du eine LED in anderer Farbe, ermittelst du den richtigen Widerstand mit dem LED-Vorwiderstandsrechner.
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}Beispiel 2: Beleuchtung im Klassenzimmer messen
In Schulen und Büros erkennst du nicht per Schätzung, sondern per Messung, ob die Beleuchtung ausreicht. Die Norm für Innenraumbeleuchtung, die auch in der Türkei gilt (TS EN 12464-1, entspricht der europäischen EN 12464-1), empfiehlt für allgemeine Klassenräume auf der Arbeitsfläche im Mittel mindestens 300 Lux, für Abendklassen, Erwachsenenbildung und die Tafel 500 Lux. Für eine korrekte Messung legst du den Sensor auf einer Tischhöhe von etwa 75–80 cm waagerecht auf den Tisch, die lichtempfindliche Seite zur Decke, und wirfst keinen eigenen Schatten darauf. Teile den Raum in ein gedachtes Raster; miss vorne, in der Mitte, hinten sowie an den Tischen auf der Fenster- und der Flurseite getrennt und notiere Mittelwert und niedrigsten Wert. Weil Tageslicht die Werte stark verändert, wiederhole die Messung einmal mittags bei offenen Vorhängen und einmal bei geschlossenen Vorhängen nur mit Lampenlicht. Das ist auch ein starkes Datenprojekt für Jugend forscht oder die Wissenschaftsmesse.
| Bereich | Empfohlene mittlere Beleuchtungsstärke (TS EN 12464-1) |
|---|---|
| Flur | 100 lx |
| Allgemeiner Klassenraum (Primar- und Sekundarstufe) | 300 lx |
| Computerraum | 300 lx |
| Sporthalle | 300 lx |
| Abendklassen und Erwachsenenbildung | 500 lx |
| Tafel | 500 lx |
| Labor | 500 lx |
| Leseplatz in der Bibliothek | 500 lx |
| Technisches Zeichnen | 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 am ESP32: LED, die sich dem Umgebungslicht anpasst
Am ESP32 läuft dieselbe BH1750-Bibliothek; der einzige Unterschied ist, dass du die I2C-Pins mit Wire.begin(21, 22) ausdrücklich angibst. In diesem Beispiel schalten wir die Lampe nicht ein und aus, sondern regeln die LED-Helligkeit stufenlos nach dem Umgebungslicht: Bei 0 Lux leuchtet die LED voll, ab 200 Lux ist sie ganz aus, dazwischen wird sie linear gedimmt. Am ESP32 wird das PWM-Signal von der LEDC-Einheit erzeugt, deren Funktionen sich mit Arduino Core 3.x geändert haben; der Code ist über eine ESP_ARDUINO_VERSION_MAJOR-Abfrage so aufgeteilt, dass er mit beiden Versionen kompiliert. Die Grundlagen von PWM findest du im Beitrag Was ist PWM?. Dank WLAN kannst du dieselbe Messung auch per MQTT an Home Assistant senden und in Smart-Home-Automatisierungen nutzen.
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 mit Raspberry Pi Pico und MicroPython
Auf dem Raspberry Pi Pico brauchst du für den BH1750 in MicroPython nicht einmal eine zusätzliche Bibliothek; die Befehle des Sensors sind so einfach, dass du direkt per I2C mit ihm sprechen kannst. Zuerst senden wir 0x01 (Einschalten), dann 0x10 (kontinuierlich, hohe Auflösung). Bei jedem Lesen holen wir 2 Bytes vom Sensor, setzen sie zu einer 16-Bit-Zahl zusammen und teilen durch 1,2. In der Ausgabe von i2c.scan() solltest du die Zahl 35 sehen, das ist die Dezimaldarstellung von 0x23; bei ADDR high siehst du 92, also 0x5C. Der Code setzt das Nachtlicht mit Hysterese aus dem Arduino-Beispiel mit einer LED an GP15 um. Bist du neu in MicroPython, wirf zuerst einen Blick in den Beitrag Was ist der 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)Projektideen mit dem BH1750
- Smarter Vorhang: Öffne und schließe Vorhang oder Jalousie je nach Luxwert automatisch mit einem Servomotor.
- Lichtüberwachung im Gewächshaus: Miss, wie viel Licht deine Pflanzen am Tag bekommen; reicht das Licht in deinem smarten Gewächshaus nicht aus, schalte die Pflanzenlampe ein.
- Solar-Tracker: Finde mit zwei BH1750 an den Adressen 0x23 und 0x5C die Richtung des Lichts und drehe das Panel deines Solar-Trackers dorthin.
- Automatische Displayhelligkeit: Passe wie bei Smartphones die Helligkeit eines OLED-Displays an das Umgebungslicht an.
- Belichtungsmesser für die Fotografie: Berechne den Belichtungswert für ISO 100 mit der Formel EV = log2(Lux / 2,5) und zeige ihn auf dem Display an.
- Lichtkarte fürs Klassenzimmer: Speichere die Messwerte in Google Tabellen und erstelle eine Beleuchtungskarte des Raums; ein starker Datensatz für ein Wettbewerbsprojekt.
Häufige Fehler und ihre Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| "BH1750 bulunamadi", begin() gibt false zurück | SDA und SCL vertauscht, falsche Adresse oder Wire.begin() vergessen | Kabel prüfen, I2C-Scanner starten, Adresse auf 0x23 oder 0x5C setzen |
| Wert hängt bei etwa 54.612 | Sättigung in direkter Sonne (65.535 / 1,2) | Messbereich mit setMTreg(31) erweitern |
| Wert -1 oder -2 | I2C-Lesefehler oder Sensor nicht konfiguriert | Rückgabewert von begin() prüfen, Kabel kürzen |
| Wert ändert sich nach der ersten Messung nicht mehr | Sensor ist im Einzelmessungsmodus eingeschlafen | Kontinuierlichen Modus nutzen oder vor jedem Lesen configure() aufrufen |
| Messwerte schwanken ständig | Schatten, Hand, schräg gehaltener Sensor | Mittelwert bilden, Sensor waagerecht und fest platzieren |
| Nachtlicht geht ständig an und aus | Nur eine Schwelle oder Sensor sieht die Lampe | Hysterese einbauen, Sensor von der Lampe entfernen |
| ESP32 oder Pico hängt, I2C-Fehler | Modul mit 5 V versorgt oder Kabel zu lang | Modul an 3V3 betreiben, Kabel unter 30 cm halten |
Der BH1750 ersetzt den LDR problemlos in jedem Projekt, in dem du Licht messen statt schätzen willst: vier Kabel, eine Bibliothek und direkt Lux. Reicht eine einfache Dunkelheitserkennung, bleibt der LDR die günstigste Lösung; brauchst du aber Messung, Logging oder einen Vergleich mit einer Norm, nimm den BH1750. In der BlueGrays-App findest du lichtbezogene Projekte wie Lichtstärke mit LDR und Nachtlicht, ESP32-Smart-Beleuchtung und intelligente Treppenbeleuchtung Schritt für Schritt mit Schaltplan und Code, und die BH1750-Beispiele aus diesem Beitrag lassen sich leicht darauf übertragen.
Häufige Fragen
Wie viele Lux kann der BH1750 messen?
In der Standardeinstellung misst der BH1750 etwa 1 bis 54.600 Lux mit 1 Lux Auflösung; das ergibt sich aus dem 16-Bit-Rohwert (65.535) geteilt durch 1,2. Senkst du MTreg auf 31, geht der Bereich über 100.000 Lux hinaus und reicht für direktes Sonnenlicht. Mit MTreg 254 und dem H2-Modus kannst du schwaches Licht bis hinunter zu 0,11 Lux unterscheiden.
Welche I2C-Adresse hat der BH1750?
Ist der ADDR-Pin offen oder mit GND verbunden, lautet die Adresse 0x23, bei Anschluss an 3,3 V ist sie 0x5C. So kannst du zwei BH1750 an denselben I2C-Bus hängen. Brauchst du mehr Sensoren, musst du einen I2C-Multiplexer wie den TCA9548A verwenden.
Was ist besser: BH1750 oder LDR?
Für echte Messungen ist der BH1750 deutlich besser: Er liefert direkt Lux, braucht keine Kalibrierung und reagiert ähnlich wie das menschliche Auge. Der LDR ist günstiger und reicht nur für einfache Nachtlichter, die lediglich den Beginn der Dunkelheit erkennen sollen. Willst du Werte aufzeichnen oder mit einer Norm vergleichen, nimm den BH1750.
Funktioniert der BH1750 mit 5 V?
Der BH1750-Chip arbeitet mit 2,4–3,6 V, aber Module wie der GY-302 haben einen 3,3-V-Regler, sodass du sie mit 3–5 V versorgen und direkt an einen Arduino Uno anschließen kannst. Beim ESP32 und beim Raspberry Pi Pico solltest du das Modul über den 3V3-Pin versorgen, damit auch die I2C-Leitungen auf 3,3 V bleiben.
Kann ich den BH1750 in der Sonne und im Freien nutzen?
Ja, aber in der Standardeinstellung bleibt der Wert in direkter Sonne bei etwa 54.600 Lux hängen; mit setMTreg(31) kannst du das umgehen. Zum Schutz vor Regen nimmst du eine transparente Abdeckung, bedenkst aber, dass sie einen Teil des Lichts schluckt, und gleichst die Ergebnisse mit einem Korrekturfaktor an. Schließe die Platine außerdem nicht in ein schwarzes Gehäuse ein, in dem sie sich direkt aufheizt.
Warum weicht der BH1750-Wert vom Luxmeter ab?
Die typische Genauigkeit des Sensors beträgt ±20 %, außerdem beeinflussen der Einfallswinkel des Lichts und das Farbspektrum der Lampe das Ergebnis. Lege den Sensor an dieselbe Stelle und im selben Winkel wie das Luxmeter, vergleiche bei mehreren Lichtarten und trage das Verhältnis als Korrekturfaktor in deinen Code ein. Achte auch darauf, dass dein eigener Schatten nicht auf den Sensor fällt.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Lichtstärke messen mit LDR
Willst du sehen, wie hell dein Zimmer ist, und zwar als Zahl? Der LDR, ein kleines lichtempfindliches Bauteil, misst das Umgebungslicht, und der Arduino schreibt den Wert jede halbe Sekunde auf…

Nachtlicht mit LDR
Ein kleines Nachtlicht, das von selbst angeht, wenn es dunkel wird, und am Morgen wieder ausgeht.

Messung der Lichtintensität mit dem ESP32-LDR-Modul
Echtzeit-Anzeige des ADC-Rohwerts des LDR-Moduls und des anhand von Dunkel- und Hellreferenzwerten berechneten relativen Lichtwerts in Prozent im Serial Monitor. Dieser Prozentwert ist keine Lux-Messung. Vermittelt die Kalibrierungslogik des Moduls. Sollte idealerweise vor Projekt 10 durchgeführt werden, da es zur Festlegung des Schwellenwerts dient.

ESP32 Nachtlicht mit LDR
Nachtlicht, bei dem die LED im Dunkeln automatisch ein- und im Hellen ausgeschaltet wird. Der D0-Pin (digital out) des LDR-Sensormoduls wird verwendet - die Dunkelschwelle wird mit dem kleinen Potentiometer am Modul eingestellt, das Modul selbst erzeugt den HIGH/LOW-Ausgang. ESP32 liest dieses Signal einfach mit digitalRead() aus, der Code ist sehr einfach.

ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)
Mit ESP32, PIR-Bewegungssensor, LDR-Lichtsensor und Relaismodul machen wir aus Flur, Bad oder Vorratskammer eine smarte Beleuchtung. Ist es hell, bleibt das Licht trotz Bewegung aus, so brennt es tagsüber nicht umsonst und spart Energie. Das Licht bleibt 30 Sekunden an; solange Bewegung erkannt wird, verlängert sich die Zeit automatisch.

Intelligente Treppen- und Korridorbeleuchtung
Betrittst du die Treppe oder den Flur, gehen die Lichter Stufe für Stufe in deiner Laufrichtung an.

Verwendung des LCD-Bildschirms mit I2C
Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

Raspberry Pi Pico PWM LED Fade (Atem-Effekt)
Die LED blinkt nicht mehr nur — sie atmet! Mit der PWM (Pulsweitenmodulation) des Raspberry Pi Pico steigt die Helligkeit langsam an und fällt wieder ab. Lerne die machine.PWM-Klasse, duty_u16() (16-Bit-Helligkeit 0–65535), PWM-Frequenz, range()-Schleifen und analogähnliche Ausgabe. Grundlage für RGB-Farbmischung, Motorsteuerung, Servos und Buzzer.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

