Helligkeitssensor

#BH1750 – Digitaler Helligkeitssensor

Präziser digitaler Umgebungslichtsensor zur Messung der Beleuchtungsstärke in Lux.

• BH1750 – Digitaler Helligkeitssensor
• Übersicht
• Technische Daten
• Pinbelegung & Anschluss
  • Anschlussschema (I²C)
  • Hinweise zur Verdrahtung
• Funktionsweise
• Beispielcode
  • MicroPython
  • C (Arduino Framework)
• Typische Lux-Werte zur Orientierung
• Tipps & häufige Fehler
• Weiterführende Links

#Übersicht

Der BH1750 von ROHM Semiconductor ist ein digitaler Umgebungslichtsensor, der die Beleuchtungsstärke direkt in Lux ausgibt. Er eignet sich ideal für automatische Displayhelligkeitsregelung, Beleuchtungssteuerung, Gewächshausüberwachung und fotografische Anwendungen. Der Sensor liefert bereits kalibrierte Werte und benötigt keine komplexe Umrechnung.

#Technische Daten

#Pinbelegung & Anschluss

#Anschlussschema (I²C)

#Hinweise zur Verdrahtung

• I²C-Adresse: ADDR an GND = 0x23, ADDR an VCC = 0x5C
• Pull-up-Widerstände: Viele Breakout-Boards haben bereits Pull-ups integriert

#Funktionsweise

Der BH1750 verwendet eine Photodiode mit integriertem Operationsverstärker und ADC. Das einfallende Licht erzeugt einen Photostrom, der verstärkt und digitalisiert wird. Der Sensor führt die Umrechnung in Lux intern durch und gibt einen kalibrierten 16-Bit-Wert aus.

Messmodi:

• Continuous Mode: Fortlaufende Messungen
• One-Time Mode: Einzelmessung, danach Power Down
• High Resolution (1 lx): Standardauflösung, 120 ms Messzeit
• High Resolution 2 (0.5 lx): Höhere Auflösung, 120 ms Messzeit
• Low Resolution (4 lx): Schnelle Messung, 16 ms Messzeit

#Beispielcode

#MicroPython

from machine import I2C, Pin
from time import sleep_ms

class BH1750:
    # Befehle
    POWER_DOWN = 0x00
    POWER_ON = 0x01
    RESET = 0x07
    
    # Messmodi
    CONTINUOUS_HIGH_RES = 0x10      # 1 lx Auflösung, 120 ms
    CONTINUOUS_HIGH_RES_2 = 0x11    # 0.5 lx Auflösung, 120 ms
    CONTINUOUS_LOW_RES = 0x13       # 4 lx Auflösung, 16 ms
    ONE_TIME_HIGH_RES = 0x20        # 1 lx Auflösung, einmalig
    ONE_TIME_HIGH_RES_2 = 0x21      # 0.5 lx Auflösung, einmalig
    ONE_TIME_LOW_RES = 0x23         # 4 lx Auflösung, einmalig
    
    def __init__(self, i2c, addr=0x23):
        self.i2c = i2c
        self.addr = addr
        self.mode = self.CONTINUOUS_HIGH_RES
        self._power_on()
        self._set_mode(self.mode)
    
    def _power_on(self):
        self.i2c.writeto(self.addr, bytes([self.POWER_ON]))
    
    def _power_down(self):
        self.i2c.writeto(self.addr, bytes([self.POWER_DOWN]))
    
    def _reset(self):
        self._power_on()
        self.i2c.writeto(self.addr, bytes([self.RESET]))
    
    def _set_mode(self, mode):
        self.mode = mode
        self.i2c.writeto(self.addr, bytes([mode]))
        # Wartezeit je nach Modus
        if mode in (self.CONTINUOUS_LOW_RES, self.ONE_TIME_LOW_RES):
            sleep_ms(24)
        else:
            sleep_ms(180)
    
    def read_lux(self):
        """Liest die Beleuchtungsstärke in Lux."""
        data = self.i2c.readfrom(self.addr, 2)
        raw = (data[0] << 8) | data[1]
        # Umrechnung in Lux (Faktor 1.2 laut Datenblatt)
        lux = raw / 1.2
        return lux
    
    def set_high_resolution(self):
        """Setzt hohe Auflösung (1 lx)."""
        self._set_mode(self.CONTINUOUS_HIGH_RES)
    
    def set_high_resolution_2(self):
        """Setzt sehr hohe Auflösung (0.5 lx)."""
        self._set_mode(self.CONTINUOUS_HIGH_RES_2)
    
    def set_low_resolution(self):
        """Setzt niedrige Auflösung (4 lx), schnellere Messung."""
        self._set_mode(self.CONTINUOUS_LOW_RES)


# Hauptprogramm
i2c = I2C(0, scl=Pin(23), sda=Pin(22), freq=400000)

# I²C-Scan zur Überprüfung
devices = i2c.scan()
print(f"Gefundene I²C-Geräte: {[hex(d) for d in devices]}")

# Sensor initialisieren
sensor = BH1750(i2c)

# Messwerte ausgeben
while True:
    lux = sensor.read_lux()
    print(f"Helligkeit: {lux:.1f} lx")
    
    # Beleuchtungssituation einschätzen
    if lux < 10:
        print("  -> Dunkel")
    elif lux < 50:
        print("  -> Schwach beleuchtet")
    elif lux < 200:
        print("  -> Normale Innenbeleuchtung")
    elif lux < 1000:
        print("  -> Helle Innenbeleuchtung")
    elif lux < 10000:
        print("  -> Bewölkter Tag / Schatten")
    else:
        print("  -> Direktes Sonnenlicht")
    
    print("-" * 30)
    sleep_ms(1000)

    
    
    
    Copy

#C (Arduino Framework)

#include <Wire.h>
#include <BH1750.h>

// I²C-Pins für das Lernboard
#define I2C_SDA 22
#define I2C_SCL 23

// I²C-Adresse des Sensors
#define BH1750_ADDR 0x23

BH1750 lightMeter(BH1750_ADDR);

void setup() {
    Serial.begin(115200););
    while (!Serial) delay(10););
    
    // I²C mit den Board-spezifischen Pins initialisieren
    Wire.begin(I2C_SDA, I2C_SCL);
    
    Serial.println("BH1750 Test - Lernboard");
    
    // Sensor initialisieren
    if (!lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE)) {
        Serial.println("BH1750 nicht gefunden!");
        Serial.println("Verkabelung prüfen.");
        while (1) delay(10);) delay(10););
    }
    
    Serial.println("BH1750 gefunden!");
    Serial.println();
}

void loop() {
    // Helligkeit auslesen
    float lux = lightMeter.readLightLevel();
    
    Serial.print("Helligkeit: ");
    Serial.print(lux);
    Serial.println(" lx");
    
    // Beleuchtungssituation einschätzen
    Serial.print("  -> ");
    if (lux < 10) {) {
        Serial.println("Dunkel");
    } else if (lux < 50) {) {
        Serial.println("Schwach beleuchtet");
    } else if (lux < 200) {) {
        Serial.println("Normale Innenbeleuchtung");
    } else if (lux < 1000) {) {
        Serial.println("Helle Innenbeleuchtung");
    } else if (lux < 10000) {) {
        Serial.println("Bewölkter Tag / Schatten");
    } else {
        Serial.println("Direktes Sonnenlicht");
    }
    
    Serial.println("------------------------------");
    delay(1000););
}

    
    
    
    Copy

Benötigte Bibliothek für Arduino:

Bibliotheksname: BH1750
Installation: Arduino IDE -> Bibliotheken verwalten -> "BH1750" suchen -> Installieren
Autor: Christopher Laws

    
    
    
    Copy

#Typische Lux-Werte zur Orientierung

#Tipps & häufige Fehler

• Sensor wird nicht erkannt: Mit einem I²C-Scanner überprüfen, ob der Sensor auf Adresse 0x23 antwortet. Falls der ADDR-Pin auf VCC liegt, ist die Adresse 0x5C.

• Messwert bleibt bei 0 oder 65535: Der Sensor benötigt nach dem Einschalten oder Moduswechsel eine Wartezeit (bis zu 180 ms). Bei 65535 ist der Messbereich überschritten.

• Schwankende Werte: Bei flackernden Lichtquellen (z.B. LED-Lampen mit PWM) können die Messwerte variieren. Mehrere Messungen mitteln für stabilere Ergebnisse.

• Infrarotlicht wird nicht erfasst: Der Sensor ist auf sichtbares Licht (400–700 nm) optimiert. IR-Fernbedienungen oder Wärmelampen werden nicht korrekt gemessen.

• Unterschiedliche Modi: Für die meisten Anwendungen ist CONTINUOUS_HIGH_RES (1 lx Auflösung) ausreichend. HIGH_RES_2 verdoppelt die Auflösung, aber auch die Messzeit.

#Weiterführende Links

• ROHM BH1750 Datenblatt (PDF)
• Arduino BH1750 Bibliothek
• BH1750 Tutorial