Componenten · 10 min leestijd

BH1750 lichtsensor voor Arduino: lux meten met I2C (volledige gids)

BH1750-luxsensor met Arduino: I2C-bedrading, meetmodi, BH1750 vs LDR, een automatisch nachtlampje en een lichtmeter voor het klaslokaal, met code voor Uno, ESP32 en Pico.

De BH1750 is een digitale 16-bits lichtsensor die het omgevingslicht direct meet in lux (lx) en communiceert via I2C. Een BH1750 aansluiten op Arduino kost maar vier draden, en in plaats van een ruwe spanning krijg je van de sensor een in de fabriek gekalibreerde, zinvolle luxwaarde. Wil je licht dus echt meten in plaats van alleen "donker of licht" bepalen, bijvoorbeeld om te controleren of een klaslokaal helder genoeg is of hoeveel licht een plant overdag krijgt, dan is dit de aangewezen module.

Hij wordt meestal verkocht als de GY-302, een klein board met een 3,3 V-regelaar en I2C-pull-upweerstanden. In dit bericht leer je hoe de sensor werkt, wat lux in het dagelijks leven betekent, hoe de sensor verschilt van een LDR, welke meetmodi er zijn en hoe je hem aansluit op een Arduino Uno, ESP32 en Raspberry Pi Pico. Daarna bouwen we twee echte toepassingen: een automatisch nachtlampje dat beschermd is tegen aan- en uitflikkeren en een lichtmeter voor het klaslokaal die de verlichting beoordeelt aan de hand van standaardwaarden.

Wat is de BH1750 en hoe werkt hij?

De BH1750 is een omgevingslichtsensor van ROHM. Binnenin zitten een fotodiode, een versterker die de stroom van de fotodiode omzet in een spanning, een 16-bits analoog-digitaalomzetter (ADC) en een I2C-interface. De spectrale respons van de fotodiode ligt dicht bij die van het menselijk oog, met een piek bij ongeveer 560 nm in het groengele gebied; infrarood licht wordt grotendeels genegeerd, dus de gelezen waarde lijkt op de helderheid die je oog waarneemt. De sensor is bovendien ontworpen om 50/60 Hz-netflikkering te onderdrukken, zodat de metingen niet verspringen onder tl- of ledlampen. Standaard wordt het ruwe 16-bits getal gedeeld door 1,2 om lux te krijgen: een ruwe waarde van 600 betekent bijvoorbeeld 600 / 1,2 = 500 lux. De bibliotheek doet deze berekening voor je.

EigenschapWaarde
ChipROHM BH1750FVI
MeetbereikStandaard ongeveer 1–54.600 lx (ruw 0–65.535); 0,11–100.000 lx met de MTreg-instelling
Resolutie0,5 lx, 1 lx of 4 lx (afhankelijk van de modus)
ADC16-bits
NauwkeurigheidMeestal ±20%
MeettijdOngeveer 120 ms (hoge resolutie), 16 ms (lage resolutie)
VoedingChip 2,4–3,6 V; GY-302-module 3–5 V
StroomOngeveer 120 µA tijdens het meten, ongeveer 0,01 µA in slaapstand
InterfaceI2C, tot 400 kHz
I2C-adres0x23 (ADDR laag of zwevend), 0x5C (ADDR hoog)
PinnenVCC, GND, SCL, SDA, ADDR

Wat is lux? Waarden uit het dagelijks leven

Lux is de eenheid voor licht dat op een oppervlak valt: 1 lux is 1 lumen lichtstroom per vierkante meter (1 lx = 1 lm/m²). Het belangrijkste is dat lux het licht beschrijft dat het gemeten oppervlak bereikt, niet de lamp zelf. Dezelfde lamp kan 500 lux geven op een bureau en 120 lux op een muur twee meter verderop, omdat het licht van een puntbron afneemt met het kwadraat van de afstand. Onze ogen werken bovendien logaritmisch: van 50 naar 100 lux gaan merk je veel sterker dan van 1000 naar 1050 lux. De onderstaande tabel helpt je de getallen van de sensor te interpreteren.

OmgevingGeschatte verlichtingssterkte
Volle maan in een heldere nacht0,1–0,3 lx
Nachtlampje, schemerige gang5–50 lx
Onder een straatlantaarn10–20 lx
Woonkamer thuis50–200 lx
Kantoor, klaslokaal300–500 lx
Buiten op een bewolkte dag1.000–10.000 lx
Schaduw op een zonnige dag10.000–25.000 lx
Direct zonlicht32.000–100.000 lx

BH1750 vs LDR: wat is het verschil?

Een LDR (fotoweerstand) is een eenvoudig component waarvan de weerstand daalt als er meer licht is. Je sluit hem met een spanningsdeler aan op een analoge pin en krijgt een getal van 0 tot 1023; dat getal hangt af van het type LDR, de waarde van de serieweerstand, de voedingsspanning en de temperatuur. Twee verschillende LDR's kunnen in dezelfde ruimte dus verschillende waarden tonen, en je moet elk exemplaar apart kalibreren om de waarde om te rekenen naar lux. De BH1750 daarentegen is in de fabriek gekalibreerd en geeft direct lux: twee modules geven bij hetzelfde licht dicht bij elkaar liggende resultaten. Daar staat tegenover dat een LDR heel goedkoop is, werkt met elk board met een analoge pin en nog steeds genoeg is voor eenvoudige projecten die alleen duisternis hoeven te detecteren. Een ander nadeel van een LDR is dat hij traag is: bij de overgang van licht naar donker kan de weerstand honderden milliseconden of zelfs seconden nodig hebben om te stabiliseren.

EigenschapBH1750LDR
UitvoerDigitaal, direct in luxAnaloog, weerstandsverandering
KalibratieNiet nodigNodig voor lux
AansluitingI2C (SDA, SCL)Analoge pin en serieweerstand
Bereik1–54.600 lx (standaard)Relatief, niet lineair
Spectrale responsDicht bij het menselijk oogVerschilt per type
Meerdere op dezelfde bus2 (0x23 en 0x5C)Elk een eigen analoge pin
Geschikt projectMeten, loggen, verlichtingsregelingEenvoudige donker/licht-detectie

BH1750-bedrading: Arduino Uno, ESP32 en Pico

BH1750-pinArduino UnoESP32Raspberry Pi Pico
VCC5V of 3.3V3V33V3(OUT) (pin 36)
GNDGNDGNDGND (pin 38)
SCLA5GPIO 22GP5 (pin 7)
SDAA4GPIO 21GP4 (pin 6)
ADDRZwevend of GND (0x23)Zwevend of GND (0x23)Zwevend of GND (0x23)
Led voor nachtlampje (met 220 Ω)D9GPIO 25GP15 (pin 20)
Leds voor klaslokaalmeter (rood, geel, groen)D5, D6, D7--
Voed de module op de ESP32 en Pico altijd via de 3V3-pin. Op sommige GY-302-boards zijn de I2C-pull-upweerstanden rechtstreeks verbonden met VCC; als je de module voedt met 5 V, worden de SDA- en SCL-lijnen opgetrokken naar 5 V en kunnen de pinnen van deze 3,3 V-boards beschadigd raken. Een andere veelgemaakte fout is het verwisselen van SDA en SCL: dan wordt de sensor nooit gevonden en geeft de I2C-scanner een lege lijst. Als je de ADDR-pin verbindt met 3,3 V, wordt het adres 0x5C, zodat je twee BH1750's op dezelfde I2C-bus kunt zetten. Als je het adres niet weet, draai dan de scannercode uit het bericht over de I2C-LCD.

Meetmodi: welke kies je?

Modus (naam in de bibliotheek)CommandoResolutieMeettijdWanneer gebruiken
CONTINUOUS_HIGH_RES_MODE0x101 lx~120 msAlgemeen gebruik, standaard
CONTINUOUS_HIGH_RES_MODE_20x110,5 lx~120 msSchemerige omgevingen, metingen in de nacht
CONTINUOUS_LOW_RES_MODE0x134 lx~16 msSnel veranderend licht, plotselinge flitsen
ONE_TIME_HIGH_RES_MODE0x201 lx~120 msBatterijprojecten, slaapt na het meten
ONE_TIME_HIGH_RES_MODE_20x210,5 lx~120 msOp batterij, meten bij weinig licht
ONE_TIME_LOW_RES_MODE0x234 lx~16 msSnelle meting met het laagste energieverbruik

In continue modi blijft de sensor zelf meten en lees je het laatste resultaat uit wanneer je wilt. In eenmalige modi doet de sensor één meting en gaat daarna in power-down; omdat de slaapstroom dan ver onder 1 µA zakt, is dit ideaal voor projecten op batterij, bijvoorbeeld projecten die elke 10 minuten wakker worden met ESP32 deep sleep. Wil je de gevoeligheid verder aanpassen, dan kun je het meettijdregister (MTreg) gebruiken. De standaardwaarde is 69; verhogen naar 254 vergroot de gevoeligheid ongeveer 3,7 keer en laat je in H2-modus tot 0,11 lux meten. Verlagen naar 31 vergroot het bereik tot boven 100.000 lux en lost het probleem op dat de waarde in direct zonlicht tegen het plafond blijft hangen. In de bibliotheek doe je dit met setMTreg(value); hoe hoger de MTreg, hoe langer de meting duurt, ongeveer 440 ms bij 254.

Stap voor stap: je eerste luxmeting met Arduino

  1. Open de Library Manager in de Arduino IDE, typ BH1750 en installeer de bibliotheek "BH1750" van Christopher Laws. Kom je er tijdens de installatie niet uit, bekijk dan Arduino-bibliotheken toevoegen.
  2. Verbind VCC van de module met 5V, GND met GND, SCL met A5 en SDA met A4; laat de ADDR-pin zweven. De SDA- en SCL-pinnen naast AREF op de Uno zijn dezelfde lijnen als A4 en A5.
  3. Upload de onderstaande code en open de Serial Monitor op 9600 baud.
  4. Bedek de sensor met je hand en houd hem daarna voor de zaklamp van je telefoon: je zou de waarde moeten zien springen van een paar lux naar duizenden lux.
  5. Als de Serial Monitor "not found" meldt, controleer dan de draden en het adres en kijk of de I2C-scanner de sensor op 0x23 toont.
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() start de I2C-bus en lightMeter.begin() zet de sensor aan, stelt de gekozen modus in en geeft true terug als het gelukt is. readLightLevel() geeft de laatste meting in lux terug als float; is de waarde negatief (-1 of -2), dan is het lezen mislukt, dus het is een goede gewoonte dit te controleren voordat je de waarde in berekeningen gebruikt. In continue modus met hoge resolutie is er ongeveer elke 120 ms een nieuw resultaat, dus de lus sneller laten draaien zorgt er alleen voor dat je dezelfde waarde opnieuw leest. Ben je benieuwd hoe I2C werkt, lees dan Wat is I2C.

Voorbeeld 1: automatisch nachtlampje met de BH1750

De meest gemaakte fout bij een nachtlampje is één enkele drempel gebruiken. Kies je een drempel van 15 lux, dan schakelt de lamp meerdere keren per seconde aan en uit als de omgeving rond 14–16 lux zit, bijvoorbeeld bij schemering. De oplossing is hysterese, oftewel twee aparte drempels: de lamp gaat aan als het licht onder 10 lux zakt, maar gaat pas uit als het boven 25 lux komt. In de tussenliggende zone rond 15 lux behoudt de lamp zijn huidige toestand. In de onderstaande code gebruiken we een led die via een weerstand van 220 Ω op D9 is aangesloten; voor een echte lamp kun je in plaats van de led een relaismodule aansluiten. Gebruik je een led van een andere kleur, bereken dan de juiste weerstand met de ledweerstandcalculator.

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}
Plaats de sensor op een plek waar hij het licht van de lamp niet kan zien. Ziet de BH1750 de lamp wel, dan wordt de omgeving helderder zodra de lamp aangaat, wordt de uitschakeldrempel overschreden, gaat de lamp uit, wordt het donker en begint de cyclus opnieuw. Door de sensor naar het raam of het plafond te richten en de lamp erachter te plaatsen, verdwijnt dit terugkoppelingsprobleem. Wil je niet dat de schaduw van iemand die voorbijloopt de lamp activeert, gebruik dan het gemiddelde van de laatste 5–10 metingen.

Voorbeeld 2: verlichtingsmeting in een klaslokaal

Op scholen en kantoren ontdek je of de verlichting voldoende is door te meten, niet door te gokken. De ook in Turkije gebruikte norm voor binnenverlichting TS EN 12464-1 (gebaseerd op de Europese EN 12464-1) adviseert gemiddeld minimaal 300 lux op het werkvlak voor gewone klaslokalen en 500 lux voor avondlessen, volwassenenonderwijs en het whiteboard. Plaats de sensor voor een nauwkeurige meting plat op een bureau op ongeveer 75–80 cm hoogte, met de lichtgevoelige kant naar het plafond, en werp zelf geen schaduw erop. Verdeel het klaslokaal in een denkbeeldig raster; meet apart voorin, in het midden, achterin en bij de tafels aan de raam- en gangzijde, en noteer dan het gemiddelde en de laagste waarde. Omdat daglicht de waarden sterk beïnvloedt, herhaal je de meting één keer 's middags met open gordijnen en één keer met gesloten gordijnen en alleen de lampen aan. Dit is ook een sterk project voor dataverzameling voor een wetenschapsbeurs of wedstrijd.

RuimteAanbevolen gemiddelde verlichtingssterkte (TS EN 12464-1)
Gang100 lx
Gewoon klaslokaal (primair en secundair onderwijs)300 lx
Computerlokaal300 lx
Gymzaal300 lx
Avondlessen en volwassenenonderwijs500 lx
Whiteboard500 lx
Laboratorium500 lx
Leeshoek van de bibliotheek500 lx
Tekenlokaal voor technisch tekenen750 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 met de ESP32: een led die dimt met de omgeving

Dezelfde BH1750-bibliotheek werkt op de ESP32; het enige verschil is dat je de I2C-pinnen expliciet opgeeft met Wire.begin(21, 22). In dit voorbeeld schakelen we de lamp niet aan en uit, maar passen we de helderheid van de led geleidelijk aan op het omgevingslicht aan: bij 0 lux brandt de led op volle sterkte, bij 200 lux en meer is hij helemaal uit, en daartussen dimt hij lineair. Op de ESP32 wordt het PWM-signaal opgewekt door de LEDC-eenheid, en de functies van deze eenheid zijn veranderd met Arduino core 3.x; de code is gesplitst met een ESP_ARDUINO_VERSION_MAJOR-controle, zodat hij op beide versies compileert. De logica van PWM vind je in Wat is PWM. Dankzij de Wi-Fi van de ESP32 kun je dezelfde meting ook via MQTT naar Home Assistant sturen en gebruiken in slimme-woningautomatiseringen.

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 met Raspberry Pi Pico en MicroPython

Op de Raspberry Pi Pico heb je voor de BH1750 met MicroPython zelfs geen extra bibliotheek nodig; de commando's van de sensor zijn zo eenvoudig dat je er rechtstreeks via I2C mee kunt praten. Eerst sturen we 0x01 (aan), daarna 0x10 (continu, hoge resolutie). Bij elke meting halen we vervolgens 2 bytes uit de sensor, voegen die samen tot één 16-bits getal en delen door 1,2. In de uitvoer van i2c.scan() zou je het getal 35 moeten zien, het decimale equivalent van hexadecimaal 0x23; is ADDR hoog, dan zie je 92, oftewel 0x5C. De code implementeert het nachtlampje met hysterese uit het Arduino-voorbeeld met een led op GP15. Ben je nieuw met MicroPython, lees dan eerst Wat is de 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)

Projectideeën met de BH1750

  • Slim gordijn: Open en sluit automatisch een gordijn of jaloezie met een servomotor op basis van de luxwaarde.
  • Lichtbewaking in de kas: Meet het licht dat planten overdag krijgen; schiet het licht tekort in je project slimme kas, schakel dan de kweeklamp in.
  • Zonvolger: Gebruik twee BH1750's op adres 0x23 en 0x5C om te bepalen uit welke richting het licht komt en draai het paneel van je zonvolger die kant op.
  • Automatische schermhelderheid: Pas de helderheid van een OLED-display aan op het omgevingslicht, zoals op telefoons.
  • Lichtmeter voor fotografie: Bereken de belichtingswaarde voor ISO 100 met de formule EV = log2(lux / 2.5) en toon die op een display.
  • Lichtkaart van het klaslokaal: Log de metingen naar Google Sheets en teken een verlichtingskaart van het klaslokaal; het is een sterke dataset voor een project voor een wetenschapswedstrijd.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
"BH1750 not found", begin() geeft false terugSDA en SCL verwisseld, verkeerd adres of Wire.begin() vergetenControleer de draden, draai de I2C-scanner, stel het adres in op 0x23 of 0x5C
Waarde blijft hangen rond 54.612Verzadiging in direct zonlicht (65.535 / 1,2)Vergroot het bereik met setMTreg(31)
Waarde is -1 of -2I2C-leesfout of sensor niet geconfigureerdControleer wat begin() teruggeeft, kort de draden in
Waarde verandert na de eerste meting nooit meerSensor is in slaapstand gegaan in eenmalige modusGebruik continue modus of roep configure() aan vóór elke meting
Metingen blijven schommelenSchaduw, hand, sensor schuin gehoudenNeem een gemiddelde, monteer de sensor plat en stabiel
Nachtlampje flikkert aan en uitEnkele drempel of de sensor ziet de lampVoeg hysterese toe, plaats de sensor verder van de lamp
ESP32 of Pico loopt vast, I2C-foutModule gevoed met 5 V of draden te langVoed de module met 3V3, houd draden korter dan 30 cm

De BH1750 vervangt de LDR gemakkelijk in elk project waarin je licht wilt meten in plaats van gokken: vier draden, één bibliotheek en direct lux. Is eenvoudige donkerdetectie genoeg, dan blijft de LDR de goedkoopste oplossing; heb je meten, loggen of vergelijken met een norm nodig, kies dan de BH1750. In de BlueGrays-app vind je lichtgerelateerde projecten, zoals lichtsterkte uitlezen met een LDR en een nachtlampje, slimme ESP32-verlichting en slimme trapverlichting, stap voor stap met schakelschema's en code, en je kunt de BH1750-voorbeelden uit dit bericht er gemakkelijk op aanpassen.

Veelgestelde vragen

Hoeveel lux kan de BH1750 meten?

Standaard meet de BH1750 ruwweg 1 tot 54.600 lux met een resolutie van 1 lux; dit komt doordat de ruwe 16-bits waarde (65.535) door 1,2 wordt gedeeld. Verlaag je MTreg naar 31, dan gaat het bereik boven 100.000 lux, zodat je direct zonlicht kunt meten. Verhoog je MTreg naar 254 en gebruik je H2-modus, dan kun je zwak licht onderscheiden tot 0,11 lux.

Wat is het I2C-adres van de BH1750?

Het adres is 0x23 als de ADDR-pin zweeft of met GND is verbonden, en 0x5C als hij met 3,3 V is verbonden. Zo kun je twee BH1750's op dezelfde I2C-bus zetten. Heb je meer sensoren nodig, dan heb je een I2C-multiplexer nodig, zoals de TCA9548A.

Wat is beter, BH1750 of LDR?

Voor echt meten is de BH1750 veel beter; hij geeft direct lux, heeft geen kalibratie nodig en reageert vergelijkbaar met het menselijk oog. Een LDR is goedkoper en alleen goed genoeg voor eenvoudige nachtlampjes die alleen hoeven te detecteren wanneer het donker wordt. Ga je waarden loggen of met een norm vergelijken, kies dan de BH1750.

Werkt de BH1750 op 5 V?

De BH1750-chip werkt op 2,4–3,6 V, maar modules zoals de GY-302 hebben een 3,3 V-regelaar, dus de module kan met 3–5 V gevoed worden en rechtstreeks op een Arduino Uno worden aangesloten. Voed de module op de ESP32 en Raspberry Pi Pico via de 3V3-pin, zodat ook de I2C-lijnen op 3,3 V blijven.

Kan de BH1750 in zonlicht en buiten worden gebruikt?

Ja, maar standaard blijft de waarde in direct zonlicht hangen op ongeveer 54.600 lux; dit omzeil je met setMTreg(31). Gebruik een transparante afdekking om de sensor tegen regen te beschermen, maar bedenk dat de afdekking een deel van het licht absorbeert en pas de resultaten aan met een correctiefactor. Het is ook belangrijk het board niet in een zwarte doos te stoppen, waar het direct zou opwarmen.

Waarom wijkt mijn BH1750-meting af van een luxmeter?

De typische nauwkeurigheid van de sensor is ±20%, en ook de hoek van het binnenkomende licht en het kleurspectrum van de lamp beïnvloeden het resultaat. Plaats de sensor op dezelfde plek en onder dezelfde hoek als de luxmeter, vergelijk ze onder een paar verschillende lichtbronnen en voeg de verhouding ertussen als correctiefactor toe aan je code. Zorg er ook voor dat je eigen schaduw tijdens het meten niet op de sensor valt.

Alle projecten bekijken
Lichtsterkte meten met een LDR
AR-11Beginner

Lichtsterkte meten met een LDR

Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

4.6(83)
143
Nachtlampje met LDR
AR-12Beginner

Nachtlampje met LDR

Een klein nachtlampje dat vanzelf aangaat als het donker wordt en uitgaat als het ochtend is.

4.7(105)
224
Lichtsterkte meten met de ESP32 en een LDR-module
ES-11Beginner

Lichtsterkte meten met de ESP32 en een LDR-module

Volg in de Serial Monitor in realtime de ruwe ADC-waarde van de LDR-module en het relatieve lichtpercentage, berekend uit referentiewaarden voor donker en licht. Dit percentage is geen luxmeting. Je leert hoe de module gekalibreerd wordt. Ideaal om vóór Project 10 te doen, want je gebruikt het om de drempelwaarde te bepalen.

4.6(36)
55
ESP32-nachtlampje met LDR
ES-10Beginner
Premium

ESP32-nachtlampje met LDR

Nachtlampje waarvan de LED in het donker automatisch aangaat en bij licht uit. Je gebruikt de D0-pin (digitale uitgang) van de LDR-sensormodule: de donkerdrempel stel je in met de kleine potmeter op de module en de module zelf geeft het HIGH/LOW-signaal. De ESP32 leest dit signaal alleen met digitalRead(); de code is heel eenvoudig.

4.6(17)
30
ESP32 slimme verlichting (PIR + LDR + relais + OLED)
ES-37Gevorderd
Premium

ESP32 slimme verlichting (PIR + LDR + relais + OLED)

Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.

4.3(6)
11
Slimme trap- en gangverlichting
AR-82Gemiddeld
Premium

Slimme trap- en gangverlichting

Stap op de trap of in de gang en de lampjes gaan trede voor trede aan, in de richting waarin je loopt.

5.0(36)
52
Een lcd-scherm gebruiken met I2C
AR-32Beginner
Premium

Een lcd-scherm gebruiken met I2C

Geef je Arduino een eigen scherm en laat hem zijn eerste bericht schrijven. Het lcd-scherm met twee regels sluit je aan met maar een paar draden; op de bovenste regel verschijnt een groet, daarna een…

4.8(53)
70
Raspberry Pi Pico PWM-led-fade (ademeffect)
PI-14Beginner

Raspberry Pi Pico PWM-led-fade (ademeffect)

De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

4