Sensor Cahaya BH1750 Arduino: Mengukur Lux dengan I2C (Panduan Lengkap)
Panduan sensor lux BH1750 Arduino: pengkabelan I2C, mode pengukuran, BH1750 vs LDR, lampu tidur otomatis, dan pengukur cahaya kelas, lengkap dengan kode Uno, ESP32, dan Pico.
BH1750 adalah sensor cahaya digital 16-bit yang mengukur cahaya sekitar langsung dalam lux (lx) dan berkomunikasi lewat I2C. Menghubungkan BH1750 ke Arduino cukup dengan empat kabel, dan alih-alih tegangan mentah, sensor ini memberimu nilai lux yang bermakna dan sudah dikalibrasi dari pabrik. Jadi kalau kamu ingin benar-benar mengukur cahaya, bukan sekadar membedakan “gelap atau terang”, misalnya untuk mengecek apakah ruang kelas cukup terang atau berapa banyak cahaya yang diterima tanaman sepanjang hari, inilah modul andalannya.
Sensor ini biasanya dijual dengan nama GY-302, yaitu board kecil yang dilengkapi regulator 3,3 V dan resistor pull-up I2C. Di artikel ini kamu akan belajar cara kerja sensor, arti lux dalam kehidupan sehari-hari, bedanya dengan LDR, mode pengukuran, dan cara menghubungkannya ke Arduino Uno, ESP32, dan Raspberry Pi Pico. Setelah itu kita akan membuat dua aplikasi nyata: lampu tidur otomatis yang terlindung dari nyala-mati yang tidak stabil, dan pengukur cahaya kelas yang menilai pencahayaan berdasarkan nilai standar.
Apa itu BH1750 dan bagaimana cara kerjanya?
BH1750 adalah sensor cahaya sekitar buatan ROHM. Di dalamnya ada fotodioda, penguat yang mengubah arus fotodioda menjadi tegangan, konverter analog ke digital (ADC) 16-bit, dan antarmuka I2C. Respons spektral fotodiodanya mirip mata manusia, dengan puncak sekitar 560 nm di daerah hijau-kuning; sensor ini sebagian besar mengabaikan cahaya inframerah, sehingga nilai yang dibacanya mirip dengan kecerahan yang ditangkap matamu. Sensor ini juga dirancang untuk meredam kedipan listrik PLN 50/60 Hz, jadi pembacaan tidak melompat-lompat di bawah lampu neon atau LED. Secara default, angka mentah 16-bit dibagi 1,2 untuk mendapatkan lux: misalnya, nilai mentah 600 berarti 600 / 1,2 = 500 lux. Library akan menghitung ini untukmu.
| Fitur | Nilai |
|---|---|
| Chip | ROHM BH1750FVI |
| Rentang pengukuran | Sekitar 1–54.600 lx secara default (mentah 0–65.535); 0,11–100.000 lx dengan pengaturan MTreg |
| Resolusi | 0,5 lx, 1 lx, atau 4 lx (tergantung mode) |
| ADC | 16-bit |
| Akurasi | Umumnya ±20% |
| Waktu pengukuran | Sekitar 120 ms (resolusi tinggi), 16 ms (resolusi rendah) |
| Catu daya | Chip 2,4–3,6 V; modul GY-302 3–5 V |
| Arus | Sekitar 120 µA ketika mengukur, sekitar 0,01 µA ketika sleep |
| Antarmuka | I2C, hingga 400 kHz |
| Alamat I2C | 0x23 (ADDR LOW atau mengambang), 0x5C (ADDR HIGH) |
| Pin | VCC, GND, SCL, SDA, ADDR |
Apa itu lux? Nilai dalam kehidupan sehari-hari
Lux adalah satuan cahaya yang jatuh ke suatu permukaan: 1 lux sama dengan fluks cahaya 1 lumen per meter persegi (1 lx = 1 lm/m²). Yang penting, lux menggambarkan cahaya yang sampai ke permukaan yang kamu ukur, bukan lampunya sendiri. Lampu yang sama bisa memberi 500 lux di meja dan 120 lux di dinding yang berjarak dua meter, karena cahaya dari sumber titik berkurang sebanding dengan kuadrat jarak. Mata kita juga bekerja secara logaritmik: naik dari 50 ke 100 lux terasa jauh lebih jelas dibanding naik dari 1000 ke 1050 lux. Tabel di bawah membantumu menafsirkan angka yang dibaca dari sensor.
| Lingkungan | Perkiraan iluminansi |
|---|---|
| Bulan purnama di malam cerah | 0,1–0,3 lx |
| Lampu tidur, lorong remang | 5–50 lx |
| Di bawah lampu jalan | 10–20 lx |
| Ruang keluarga di rumah | 50–200 lx |
| Kantor, ruang kelas | 300–500 lx |
| Luar ruangan ketika mendung | 1000–10.000 lx |
| Tempat teduh di hari cerah | 10.000–25.000 lx |
| Sinar matahari langsung | 32.000–100.000 lx |
BH1750 vs LDR: apa bedanya?
LDR (fotoresistor) adalah komponen sederhana yang hambatannya turun ketika cahaya bertambah. Kamu menghubungkannya ke pin analog dengan pembagi tegangan dan mendapat angka 0 sampai 1023; angka itu bergantung pada jenis LDR, nilai resistor seri, tegangan catu daya, dan suhu. Jadi dua LDR yang berbeda bisa menunjukkan nilai berbeda di ruangan yang sama, dan kamu harus mengkalibrasi masing-masing untuk mengubah nilainya ke lux. Sebaliknya, BH1750 sudah dikalibrasi dari pabrik dan langsung memberi nilai lux: dua modul memberi hasil yang berdekatan di bawah cahaya yang sama. Sebagai gantinya, LDR sangat murah, bisa dipakai di board apa pun yang punya pin analog, dan masih cukup untuk proyek sederhana yang hanya perlu mendeteksi gelap. Kekurangan lain LDR adalah lambat: ketika berpindah dari terang ke gelap, hambatannya bisa butuh ratusan milidetik bahkan beberapa detik untuk stabil.
| Fitur | BH1750 | LDR |
|---|---|---|
| Output | Digital, langsung dalam lux | Analog, perubahan hambatan |
| Kalibrasi | Tidak perlu | Perlu untuk lux |
| Koneksi | I2C (SDA, SCL) | Pin analog dan resistor seri |
| Rentang | 1–54.600 lx (default) | Relatif, tidak linear |
| Respons spektral | Mirip mata manusia | Berbeda menurut jenisnya |
| Beberapa di bus yang sama | 2 buah (0x23 dan 0x5C) | Satu pin analog terpisah untuk masing-masing |
| Proyek yang cocok | Pengukuran, pencatatan, kendali pencahayaan | Deteksi gelap/terang sederhana |
Pengkabelan BH1750: Arduino Uno, ESP32, dan Pico
| Pin BH1750 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V atau 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 | Mengambang atau GND (0x23) | Mengambang atau GND (0x23) | Mengambang atau GND (0x23) |
| LED lampu tidur (dengan 220 Ω) | D9 | GPIO 25 | GP15 (pin 20) |
| LED pengukur kelas (merah, kuning, hijau) | D5, D6, D7 | - | - |
Mode pengukuran: mana yang sebaiknya dipilih?
| Mode (nama di library) | Perintah | Resolusi | Waktu pengukuran | Kapan dipakai |
|---|---|---|---|---|
| CONTINUOUS_HIGH_RES_MODE | 0x10 | 1 lx | ~120 ms | Penggunaan umum, default |
| CONTINUOUS_HIGH_RES_MODE_2 | 0x11 | 0,5 lx | ~120 ms | Lingkungan remang, pengukuran malam |
| CONTINUOUS_LOW_RES_MODE | 0x13 | 4 lx | ~16 ms | Cahaya yang cepat berubah, kilatan tiba-tiba |
| ONE_TIME_HIGH_RES_MODE | 0x20 | 1 lx | ~120 ms | Proyek baterai, sleep setelah mengukur |
| ONE_TIME_HIGH_RES_MODE_2 | 0x21 | 0,5 lx | ~120 ms | Pengukuran cahaya remang dengan baterai |
| ONE_TIME_LOW_RES_MODE | 0x23 | 4 lx | ~16 ms | Pengukuran cepat dengan energi paling rendah |
Di mode kontinu, sensor terus mengukur sendiri dan kamu bisa membaca hasil terbaru kapan pun kamu mau. Di mode sekali ukur (one-time), sensor melakukan satu pengukuran lalu masuk ke mode power-down; karena arus sleep-nya turun jauh di bawah 1 µA, mode ini ideal untuk proyek bertenaga baterai, misalnya yang bangun setiap 10 menit dengan deep sleep ESP32. Kalau ingin mengubah sensitivitas lebih jauh, kamu bisa memakai register waktu pengukuran (MTreg). Nilai default-nya 69; menaikkannya ke 254 meningkatkan sensitivitas sekitar 3,7 kali dan memungkinkanmu turun hingga 0,11 lux di mode H2. Menurunkannya ke 31 memperlebar rentang hingga melewati 100.000 lux dan mengatasi masalah nilai yang mentok di batas atas di bawah sinar matahari langsung. Di library, ini dilakukan dengan setMTreg(nilai); makin tinggi MTreg, makin lama pengukurannya, sekitar 440 ms pada nilai 254.
Langkah demi langkah: pengukuran lux pertamamu dengan Arduino
- Buka Library Manager di Arduino IDE, ketik BH1750, lalu instal library “BH1750” buatan Christopher Laws. Kalau mentok selama instalasi, lihat Cara Instal Library Arduino.
- Hubungkan VCC modul ke 5V, GND ke GND, SCL ke A5, dan SDA ke A4; biarkan pin ADDR mengambang. Pin SDA dan SCL di samping AREF pada Uno adalah jalur yang sama dengan A4 dan A5.
- Upload kode di bawah dan buka Serial Monitor di 9600 baud.
- Tutup sensor dengan tanganmu, lalu dekatkan ke senter ponselmu: nilainya seharusnya melonjak dari beberapa lux ke ribuan lux.
- Kalau Serial Monitor menampilkan “not found”, cek kabel dan alamatnya, dan pastikan scanner I2C menampilkan sensor di 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() memulai bus I2C, dan lightMeter.begin() menyalakan sensor, mengatur mode yang kamu pilih, lalu mengembalikan true jika berhasil. readLightLevel() mengembalikan hasil pengukuran terbaru dalam lux bertipe float; jika nilainya negatif (-1 atau -2), pembacaan gagal, jadi biasakan mengeceknya sebelum memakai nilai itu dalam perhitungan. Di mode kontinu resolusi tinggi, hasil baru siap kira-kira setiap 120 ms, jadi menjalankan loop lebih cepat dari itu hanya membuatmu membaca nilai yang sama lagi. Kalau penasaran cara kerja I2C, lihat Apa Itu I2C?.
Contoh 1: lampu tidur otomatis dengan BH1750
Kesalahan paling umum pada lampu tidur adalah memakai satu ambang saja. Kalau kamu memilih ambang 15 lux, ketika lingkungan berada di sekitar 14–16 lux, misalnya menjelang magrib, lampu akan nyala-mati beberapa kali per detik. Solusinya adalah histeresis, yaitu dua ambang terpisah: lampu menyala ketika cahaya turun di bawah 10 lux, tetapi baru mati ketika cahaya naik di atas 25 lux. Di zona 15 lux di antaranya, lampu mempertahankan kondisinya. Di kode di bawah, kita memakai LED yang terhubung ke D9 lewat resistor 220 Ω; untuk lampu sungguhan, kamu bisa memasang modul relay sebagai pengganti LED. Kalau kamu memakai LED dengan warna lain, cari resistor yang tepat dengan kalkulator resistor 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}Contoh 2: mengukur pencahayaan ruang kelas
Di sekolah dan kantor, cukup tidaknya pencahayaan diketahui dengan mengukur, bukan menebak. Standar pencahayaan dalam ruangan TS EN 12464-1, yang juga dipakai di Turki (dan berbasis standar Eropa EN 12464-1), merekomendasikan rata-rata minimal 300 lux di permukaan kerja untuk ruang kelas umum, dan 500 lux untuk kelas malam, pendidikan orang dewasa, dan papan tulis. Agar pengukurannya akurat, letakkan sensor mendatar di atas meja setinggi sekitar 75–80 cm dengan sisi peka cahaya menghadap langit-langit, dan jangan sampai bayanganmu jatuh di atasnya. Bagi ruang kelas menjadi grid imajiner; ukur terpisah di meja depan, tengah, belakang, serta di sisi jendela dan sisi lorong, lalu catat rata-rata dan nilai terendahnya. Karena cahaya matahari sangat memengaruhi nilai, ulangi pengukuran sekali di siang hari dengan gorden terbuka dan sekali dengan gorden tertutup dan hanya lampu yang menyala. Ini juga proyek pengumpulan data yang kuat untuk pameran sains atau lomba.
| Area | Rata-rata iluminansi yang direkomendasikan (TS EN 12464-1) |
|---|---|
| Lorong | 100 lx |
| Ruang kelas umum (SD sampai SMA) | 300 lx |
| Lab komputer | 300 lx |
| Aula olahraga | 300 lx |
| Kelas malam dan pendidikan orang dewasa | 500 lx |
| Papan tulis | 500 lx |
| Laboratorium | 500 lx |
| Area baca perpustakaan | 500 lx |
| Ruang gambar teknik | 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 dengan ESP32: LED yang meredup mengikuti lingkungan
Library BH1750 yang sama bisa dipakai di ESP32; satu-satunya perbedaan adalah kamu menentukan pin I2C secara eksplisit dengan Wire.begin(21, 22). Di contoh ini, alih-alih menyalakan dan mematikan lampu, kita mengatur kecerahan LED secara halus sesuai cahaya sekitar: di 0 lux LED menyala penuh, di 200 lux ke atas LED mati total, dan di antaranya LED meredup secara linear. Di ESP32, sinyal PWM dibuat oleh unit LEDC, dan fungsi-fungsi unit ini berubah sejak Arduino core 3.x; kodenya dipisah dengan pengecekan ESP_ARDUINO_VERSION_MAJOR agar bisa dikompilasi di kedua versi. Logika PWM bisa kamu temukan di Apa Itu PWM?. Berkat Wi-Fi ESP32, kamu juga bisa mengirim hasil pengukuran yang sama ke Home Assistant lewat MQTT dan memakainya dalam otomasi rumah pintar.
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 dengan Raspberry Pi Pico dan MicroPython
Di Raspberry Pi Pico, kamu bahkan tidak butuh library tambahan untuk memakai BH1750 dengan MicroPython; perintah sensornya begitu sederhana sehingga kamu bisa berkomunikasi langsung lewat I2C. Pertama kita kirim 0x01 (power on), lalu 0x10 (kontinu resolusi tinggi). Kemudian di setiap pembacaan kita ambil 2 byte dari sensor, menggabungkannya menjadi satu angka 16-bit, lalu membaginya dengan 1,2. Di output i2c.scan() kamu seharusnya melihat angka 35, yaitu nilai desimal dari heksadesimal 0x23; kalau ADDR HIGH, kamu akan melihat 92, yaitu 0x5C. Kode ini menerapkan lampu tidur dengan histeresis dari contoh Arduino memakai LED di GP15. Kalau kamu baru mengenal MicroPython, lihat dulu Apa Itu 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)Ide proyek dengan BH1750
- Gorden pintar: Buka dan tutup gorden atau tirai secara otomatis dengan motor servo berdasarkan nilai lux.
- Pemantauan cahaya rumah kaca: Ukur cahaya yang diterima tanaman sepanjang hari; kalau cahaya kurang di proyek rumah kaca pintar-mu, nyalakan lampu tanaman (grow lamp).
- Pelacak matahari: Pakai dua BH1750 dengan alamat 0x23 dan 0x5C untuk menemukan arah datangnya cahaya, lalu putar panel pelacak matahari-mu ke arah itu.
- Kecerahan layar otomatis: Atur kecerahan layar OLED sesuai cahaya sekitar, seperti di ponsel.
- Light meter fotografi: Hitung nilai eksposur untuk ISO 100 dengan rumus EV = log2(lux / 2,5) dan tampilkan di layar.
- Peta cahaya kelas: Catat hasil pengukuran ke Google Sheets dan buat peta pencahayaan ruang kelas; ini jadi kumpulan data yang kuat untuk proyek lomba sains.
Kesalahan umum dan cara mengatasinya
| Gejala | Kemungkinan penyebab | Solusi |
|---|---|---|
| “BH1750 not found”, begin() mengembalikan false | SDA dan SCL tertukar, alamat salah, atau Wire.begin() terlupa | Cek kabel, jalankan scanner I2C, atur alamat ke 0x23 atau 0x5C |
| Nilai mentok di sekitar 54.612 | Jenuh di bawah sinar matahari langsung (65.535 / 1,2) | Perlebar rentang dengan setMTreg(31) |
| Nilainya -1 atau -2 | Error pembacaan I2C atau sensor belum dikonfigurasi | Cek nilai kembalian begin(), perpendek kabel |
| Nilai tidak pernah berubah setelah pembacaan pertama | Sensor masuk sleep di mode sekali ukur | Pakai mode kontinu atau panggil configure() sebelum setiap pembacaan |
| Pembacaan terus naik-turun | Bayangan, tangan, sensor dipegang miring | Ambil rata-rata, pasang sensor mendatar dan stabil |
| Lampu tidur nyala-mati terus | Hanya satu ambang atau sensor melihat lampu | Tambahkan histeresis, jauhkan sensor dari lampu |
| ESP32 atau Pico macet, error I2C | Modul diberi daya 5 V atau kabel terlalu panjang | Beri daya modul dari 3V3, jaga panjang kabel di bawah 30 cm |
BH1750 dengan mudah menggantikan LDR di proyek apa pun yang ingin mengukur cahaya, bukan menebaknya: empat kabel, satu library, dan langsung lux. Kalau deteksi gelap sederhana sudah cukup, LDR masih jadi solusi termurah; tapi kalau kamu butuh pengukuran, pencatatan, atau perbandingan dengan standar, pilih BH1750. Di aplikasi BlueGrays, kamu akan menemukan proyek-proyek bertema cahaya seperti membaca intensitas cahaya dengan LDR dan lampu tidur, pencahayaan pintar ESP32, serta lampu tangga pintar, langkah demi langkah dengan skema rangkaian dan kodenya, dan kamu bisa dengan mudah menyesuaikan contoh BH1750 di artikel ini ke proyek-proyek tersebut.
Pertanyaan umum
Berapa lux yang bisa diukur BH1750?
Secara default, BH1750 mengukur kira-kira 1 sampai 54.600 lux dengan resolusi 1 lux; angka ini berasal dari nilai mentah 16-bit (65.535) yang dibagi 1,2. Kalau MTreg kamu turunkan ke 31, rentangnya melewati 100.000 lux sehingga bisa mengukur sinar matahari langsung. Kalau MTreg kamu naikkan ke 254 dan memakai mode H2, kamu bisa membedakan cahaya remang hingga 0,11 lux.
Berapa alamat I2C BH1750?
Alamatnya 0x23 ketika pin ADDR dibiarkan mengambang atau dihubungkan ke GND, dan 0x5C ketika dihubungkan ke 3,3 V. Dengan begitu kamu bisa memasang dua BH1750 di bus I2C yang sama. Kalau butuh lebih banyak sensor, kamu perlu multiplexer I2C seperti TCA9548A.
Mana yang lebih baik, BH1750 atau LDR?
Untuk pengukuran sungguhan, BH1750 jauh lebih baik; sensor ini langsung memberi nilai lux, tidak perlu kalibrasi, dan responsnya mirip mata manusia. LDR lebih murah dan hanya cukup untuk lampu tidur sederhana yang sekadar perlu mendeteksi kapan mulai gelap. Kalau kamu akan mencatat nilai atau membandingkannya dengan standar, pilih BH1750.
Apakah BH1750 bisa bekerja di 5 V?
Chip BH1750 bekerja di 2,4–3,6 V, tetapi modul seperti GY-302 punya regulator 3,3 V, jadi modulnya bisa diberi daya 3–5 V dan dihubungkan langsung ke Arduino Uno. Di ESP32 dan Raspberry Pi Pico, beri daya modul dari pin 3V3 supaya jalur I2C juga tetap di 3,3 V.
Apakah BH1750 bisa dipakai di bawah sinar matahari dan di luar ruangan?
Bisa, tetapi secara default di bawah sinar matahari langsung nilainya mentok di sekitar 54.600 lux; kamu bisa melewati batas ini dengan setMTreg(31). Pakai penutup transparan untuk melindungi sensor dari hujan, tapi ingat bahwa penutup menyerap sebagian cahaya, jadi sesuaikan hasilnya dengan faktor koreksi. Penting juga untuk tidak menutup board di dalam kotak hitam yang akan langsung memanas.
Kenapa nilai BH1750-ku berbeda dengan lux meter?
Akurasi tipikal sensor ini ±20%, dan sudut datang cahaya serta spektrum warna lampu juga memengaruhi hasilnya. Letakkan sensor di titik dan sudut yang sama dengan lux meter, bandingkan di bawah beberapa jenis cahaya, lalu tambahkan rasio di antara keduanya ke kodemu sebagai faktor koreksi. Pastikan juga bayanganmu tidak jatuh ke sensor selama pengukuran.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
Mengukur Intensitas Cahaya dengan LDR
Ingin melihat seberapa terang kamarmu dalam bentuk angka? LDR, komponen kecil yang bereaksi terhadap cahaya, mengukur cahaya di sekitarnya, dan Arduino menulis nilainya ke layar komputermu setiap…

Lampu Tidur dengan LDR
Lampu tidur kecil yang menyala sendiri ketika gelap dan mati ketika pagi tiba. Sensor cahaya mengukur seberapa terang ruangan, dan Arduino menyalakan LED ketika cukup gelap lalu mematikannya lagi…

Membaca Intensitas Cahaya dengan Modul LDR ESP32
Memantau secara real-time di Serial Monitor nilai ADC mentah modul LDR dan persentase cahaya relatif yang dihitung dari nilai acuan gelap dan terang. Persentase ini bukan pengukuran lux. Mengajarkan logika kalibrasi modul. Ideal dikerjakan sebelum Proyek 10, karena dipakai untuk menentukan nilai ambang.

Lampu Tidur dengan LDR ESP32
Lampu tidur yang LED-nya otomatis menyala ketika gelap dan mati ketika terang. Yang dipakai adalah pin D0 (digital out) Modul Sensor LDR; ambang gelap diatur dengan potensiometer kecil di modul, dan modul sendiri yang menghasilkan output HIGH/LOW. ESP32 hanya membaca sinyal ini dengan digitalRead(), jadi kodenya sangat sederhana.

Lampu Pintar ESP32 (PIR + LDR + Relay + OLED)
Ubah lorong, kamar mandi, atau gudangmu menjadi lampu pintar dengan ESP32! Dengan sensor gerak PIR, sensor cahaya LDR, dan modul relay, kita membuat skenario klasik "lampu menyala ketika ada gerakan dalam gelap"; jika sudah terang, gerakan TIDAK menyalakan lampu, jadi energi hemat di siang hari. Lampu menyala 30 detik; jika gerakan berlanjut, timer diulang. OLED SSD1306 menampilkan status dengan font besar (NYALA / SIANG / MENUNGGU) dan hitung mundur.

Lampu Tangga dan Koridor Pintar
Injak tangga atau masuk ke lorong, dan lampu menyala satu per satu ke arah kamu berjalan.

Menggunakan Layar LCD dengan I2C
Beri Arduino-mu layar sendiri dan buat ia menulis pesan pertamanya. Layar LCD dua baris tersambung hanya dengan beberapa kabel; sapaan muncul di baris atas, lalu pesan kedua di baris bawah, layar…

LED Fade PWM Raspberry Pi Pico (Efek Bernapas)
LED tidak lagi sekadar berkedip, ia bernapas! Dengan PWM (Pulse Width Modulation) Pico, kecerahan LED naik lalu turun perlahan, seperti lampu MacBook yang tidur. Pelajari kelas machine.PWM, duty_u16() (kecerahan 16-bit 0–65535), frekuensi PWM (freq(1000): 1000 siklus per detik, tanpa kedipan terlihat), loop range() bertahap, dan output mirip analog dari pin digital. PWM juga dipakai untuk warna RGB, motor, servo, dan buzzer.
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

