Tutorial VL53L0X Arduino: Sensor Jarak Laser dengan Jangkauan 2 m
Bagaimana cara memakai sensor jarak laser VL53L0X dengan Arduino, ESP32, dan Pico? Pengkabelan I2C, profil pengukuran, beberapa sensor dengan XSHUT, dan perbandingan dengan HC-SR04.
VL53L0X adalah sensor jarak laser ToF (Time of Flight, waktu tempuh), salah satu cara paling kecil dan paling presisi untuk mengukur jarak dengan Arduino. Chip buatan STMicroelectronics ini memancarkan pulsa laser 940 nm yang tidak terlihat, mengukur berapa lama cahaya memantul dari target lalu kembali, dan memberikan hasilnya langsung dalam milimeter. Modul seukuran perangko ini cukup dihubungkan lewat dua kabel data I2C; di mode default ia bisa mengukur sampai sekitar 1,2 meter, dan di mode jarak jauh sampai 2 meter.
Di panduan ini kamu akan belajar langkah demi langkah cara kerja VL53L0X, cara menghubungkannya ke Arduino Uno, ESP32, dan Raspberry Pi Pico, perbedaan keempat profil pengukurannya, serta cara memasang beberapa sensor di bus I2C yang sama dengan pin XSHUT. Kamu juga akan membandingkannya dengan sensor jarak HC-SR04 yang populer dan melihat mana yang lebih masuk akal untuk proyek apa.
Apa itu VL53L0X dan bagaimana cara kerjanya?
Di dalam sensor ada dua bagian utama: VCSEL (vertical-cavity surface-emitting laser, dioda laser yang memancarkan cahaya dari permukaannya) yang memancarkan cahaya, dan susunan SPAD (single-photon avalanche diode, dioda avalanche foton tunggal) yang bisa mendeteksi bahkan satu foton. VCSEL mengirim pulsa cahaya yang sangat pendek, susunan SPAD menangkap foton yang kembali, dan chip mengukur waktu di antaranya. Jarak didapat dari rumus sederhana: d = c × t / 2. Di sini c adalah kecepatan cahaya (sekitar 300.000 km/dtk), dan karena cahaya menempuh lintasan dua kali, hasilnya dibagi dua. Untuk benda yang berjarak 1 meter, waktu pulang-perginya hanya 6,67 nanodetik. Mengukur waktu sesingkat itu dengan satu pulsa hampir mustahil, jadi chip mengumpulkan statistik dari ribuan pulsa dan menghitungnya sendiri di dalam; kamu tinggal membaca hasil jadinya.
Lasernya termasuk Kelas 1, jadi tidak berbahaya bagi mata dalam pemakaian normal, dan karena inframerah, kamu tidak bisa melihatnya. Sudut pandang sensor sekitar 25 derajat, jadi pengukuran terjadi di dalam kerucut yang sempit. Dengan begitu kamu bisa membidik jauh lebih tepat dibanding gelombang suara HC-SR04 yang lebar; kamu bisa mengukur benda kecil di tepi meja tanpa ikut menangkap dinding di sebelahnya. Karena hasilnya bergantung pada kecepatan cahaya, suhu udara dan kelembapan hampir tidak berpengaruh.
| Fitur | Nilai |
|---|---|
| Chip | STMicroelectronics VL53L0X |
| Prinsip pengukuran | Waktu tempuh (ToF), laser VCSEL 940 nm, Kelas 1 |
| Jangkauan | Sekitar 3 cm – 1,2 m (default), sampai 2 m (mode jarak jauh, lingkungan gelap, target putih) |
| Resolusi | 1 mm |
| Akurasi | Sekitar ±3% – ±5% tergantung mode |
| Sudut pandang | Sekitar 25° |
| Waktu pengukuran | 20 ms – 200 ms (tergantung timing budget) |
| Catu daya | Chip 2,6–3,5 V; kebanyakan modul punya regulator, 3,3–5 V |
| Arus | Sekitar 19 mA selama mengukur, beberapa µA dalam mode standby |
| Antarmuka | I2C, sampai 400 kHz, alamat default 0x29 |
| Pin | VIN, GND, SCL, SDA, GPIO1 (interrupt), XSHUT (shutdown) |
VL53L0X atau HC-SR04?
Kedua sensor sama-sama mengukur jarak, tapi fisikanya benar-benar berbeda. HC-SR04 mengirim gelombang suara 40 kHz lalu mendengarkan gemanya; suara merambat sekitar 343 m/dtk, jadi pengaturan waktunya mudah dan jangkauannya sampai 4 meter. Namun, kerucut suaranya yang lebar juga menangkap benda di samping, dan kain, busa, serta permukaan miring menyerap atau membelokkan suara. VL53L0X mengukur dengan cahaya: ukurannya mungil, membidik target dengan sudut sempit, lebih stabil di jarak pendek, dan berkat I2C banyak sensor bisa berbagi satu bus. Di sisi lain, sinar matahari langsung, permukaan yang sangat gelap atau mengilap seperti cermin, dan kaca menyulitkannya. Singkatnya: kalau kamu butuh pengukuran kecil dan cepat di bawah 2 meter, pilih VL53L0X; kalau butuh jangkauan lebih jauh dan pemakaian di luar ruangan, HC-SR04 lebih masuk akal. Untuk pilihan lain, lihat perbandingan sensor jarak.
| Fitur | VL53L0X | HC-SR04 |
|---|---|---|
| Prinsip pengukuran | Waktu tempuh cahaya laser (940 nm) | Gema suara ultrasonik (40 kHz) |
| Jangkauan | Sekitar 3 cm – 2 m | Sekitar 2 cm – 4 m |
| Kerucut pengukuran | Sekitar 25°, sempit dan teratur | Sudut ukur sekitar 15°, suara menyebar lebih lebar |
| Resolusi | 1 mm | Sekitar 3 mm (±1 cm dalam praktik) |
| Koneksi | I2C (SDA, SCL) | 2 pin digital (Trig, Echo) |
| Beberapa sensor | Di bus I2C yang sama dengan XSHUT | Pin terpisah untuk tiap sensor, bisa saling mendengar gema |
| Catu daya | 3,3–5 V (modul) | 5 V |
| Ukuran | Sekitar 25 × 13 mm | Sekitar 45 × 20 mm |
| Kesulitan dengan | Permukaan hitam atau mengilap seperti cermin, kaca, sinar matahari | Kain, busa, permukaan miring, lingkungan bising |
Pengkabelan VL53L0X: Arduino Uno, ESP32, dan Pico
Kebanyakan modul di pasaran (seperti GY-530 dan GY-VL53L0XV2) sudah membawa regulator 2,8 V, resistor pull-up untuk jalur I2C, dan resistor pull-up untuk XSHUT. Artinya kamu bisa menghubungkan modul ke pin 5V di Uno, atau ke pin 3V3 di ESP32 dan Pico. Kebanyakan modul murah bisa berkomunikasi dengan Uno tanpa masalah; tetap saja, untuk proyek yang akan berjalan lama kamu bisa memakai konverter level logika untuk melindungi jalur I2C. Kalau penasaran cara kerja bus I2C, baca Apa Itu I2C?. GPIO1 adalah output interrupt yang memberi sinyal ketika pengukuran selesai; untuk pemakaian dasar kamu tidak perlu menyambungkannya.
| Pin VL53L0X | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN | 5V (atau 3.3V) | 3V3 | 3V3(OUT) |
| GND | GND | GND | GND |
| SCL | A5 | GPIO 22 | GP5 |
| SDA | A4 | GPIO 21 | GP4 |
| XSHUT (opsional) | D4 (D5 untuk sensor ke-2) | GPIO 25 | GP6 |
| GPIO1 (opsional) | Tidak disambung | Tidak disambung | Tidak disambung |
Langkah demi langkah: pengukuran pertama dengan Arduino
- Sambungkan kabel sesuai tabel: VIN → 5V, GND → GND, SDA → A4, SCL → A5.
- Kalau ada selotip pelindung kuning atau oranye di atas sensor, lepaskan dengan hati-hati; selotip itu merusak pengukuran sepenuhnya.
- Di Arduino IDE buka Library Manager, ketik VL53L0X, lalu instal library buatan Pololu. Adafruit_VL53L0X juga bisa, tapi karena berisi API lengkap dari ST, library itu memakan jauh lebih banyak memori di Uno. Kalau mentok ketika menginstalnya, lihat Cara Instal Library Arduino.
- Upload kode di bawah dan buka Serial Monitor di 115200 baud.
- Gerakkan tanganmu mendekat dan menjauh dari sensor, lalu lihat nilainya berubah dalam milimeter dan sentimeter.
1#include <Wire.h>
2#include <VL53L0X.h>
3
4VL53L0X sensor;
5
6void setup() {
7 Serial.begin(115200);
8 Wire.begin(); // Uno: SDA=A4, SCL=A5
9 sensor.setTimeout(500); // 500 ms cevap bekle / wait 500 ms for a reply
10 if (!sensor.init()) {
11 Serial.println(F("VL53L0X bulunamadi / not found"));
12 while (1) {}
13 }
14 sensor.startContinuous(); // sürekli ölçüm / continuous ranging
15}
16
17void loop() {
18 uint16_t mm = sensor.readRangeContinuousMillimeters();
19 if (sensor.timeoutOccurred()) {
20 Serial.println(F("Zaman asimi / Timeout"));
21 return;
22 }
23 if (mm > 2000) { // geçerli yansıma yok / no valid return
24 Serial.println(F("Menzil disi / Out of range"));
25 } else {
26 Serial.print(mm);
27 Serial.print(F(" mm = "));
28 Serial.print(mm / 10.0, 1);
29 Serial.println(F(" cm"));
30 }
31 delay(100);
32}| Perintah | Fungsinya apa? |
|---|---|
| sensor.setTimeout(500) | Berhenti menunggu kalau sensor tidak menjawab dalam 500 ms, jadi kode tidak macet selamanya. |
| sensor.init() | Memuat urutan pengaturan dari ST dan menjalankan kalibrasi SPAD; kalau hasilnya false, sensor tidak ditemukan di bus I2C. |
| sensor.startContinuous() | Membuat sensor mengukur terus-menerus tanpa jeda. |
| sensor.readRangeContinuousMillimeters() | Mengembalikan hasil pengukuran terakhir dalam milimeter; kalau tidak ada target, kamu mendapat nilai sekitar 8190. |
| sensor.timeoutOccurred() | Mengembalikan true kalau pembacaan terakhir mengalami timeout (nilainya lalu menjadi 65535). |
Mode pengukuran VL53L0X
Tiga pengaturan menentukan kualitas pengukuran di VL53L0X: timing budget (waktu yang diberikan untuk satu pengukuran), batas laju sinyal (pantulan terlemah yang masih dianggap valid), dan periode pulsa VCSEL (panjang pulsa laser). Makin besar budget-nya, makin banyak foton yang dikumpulkan sensor dan makin stabil pembacaannya, tapi makin lambat; budget 200 ms berarti hanya 5 pengukuran per detik. Menurunkan batas sinyal dari default 0,25 MCPS ke 0,1 MCPS membuat pantulan lemah ikut diterima dan memperjauh jangkauan, tapi menaikkan risiko pembacaan yang salah. Menaikkan periode pulsa dari default 14 dan 10 menjadi 18 dan 14 mengirim lebih banyak energi ke target yang jauh. ST mendefinisikan pengaturan ini sebagai empat profil siap pakai; di kode di bawah kamu bisa memilih profil yang kamu mau dengan menghapus tanda komentar di awal barisnya. Kamu juga bisa menggabungkan pengaturan jarak jauh dengan pengaturan kecepatan atau akurasi.
| Profil | Timing budget | Jangkauan tipikal | Akurasi | Kapan dipakai? |
|---|---|---|---|---|
| Default | Sekitar 30 ms | 1,2 m | Sekitar ±3–4% | Pengukuran serba guna |
| Akurasi tinggi | 200 ms | 1,2 m | Di bawah ±3% | Pengukuran level, penggaris presisi |
| Jarak jauh | 33 ms | 2 m | Sekitar ±4% | Lingkungan gelap, target jauh |
| Kecepatan tinggi | 20 ms | 1,2 m | Sekitar ±5% | Robot cepat, deteksi gerakan tangan |
1#include <Wire.h>
2#include <VL53L0X.h>
3
4VL53L0X sensor;
5
6// Profil seç: istediğin satırın yorumunu kaldır / Pick a profile: uncomment the line you want
7#define UZUN_MENZIL // uzun menzil / long range
8//#define YUKSEK_HIZ // yüksek hız / high speed
9//#define YUKSEK_DOGRULUK // yüksek doğruluk / high accuracy
10
11void setup() {
12 Serial.begin(115200);
13 Wire.begin();
14 sensor.setTimeout(500);
15 if (!sensor.init()) {
16 Serial.println(F("Sensor yok / No sensor"));
17 while (1) {}
18 }
19
20#if defined UZUN_MENZIL
21 sensor.setSignalRateLimit(0.1); // varsayılan 0.25 MCPS / default 0.25 MCPS
22 sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18); // varsayılan 14 / default 14
23 sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14); // varsayılan 10 / default 10
24#endif
25
26#if defined YUKSEK_HIZ
27 sensor.setMeasurementTimingBudget(20000); // 20 ms
28#elif defined YUKSEK_DOGRULUK
29 sensor.setMeasurementTimingBudget(200000); // 200 ms
30#endif
31}
32
33void loop() {
34 Serial.print(sensor.readRangeSingleMillimeters()); // tek seferlik ölçüm / single-shot ranging
35 if (sensor.timeoutOccurred()) {
36 Serial.print(F(" ZAMAN ASIMI / TIMEOUT"));
37 }
38 Serial.println();
39}Beberapa sensor VL53L0X: mengganti alamat dengan XSHUT
Setiap VL53L0X keluar dari pabrik dengan alamat yang sama, 0x29, dan alamat ini tidak bisa diubah secara permanen. Kalau kamu menyambung dua sensor langsung di bus yang sama, keduanya menjawab bersamaan dan komunikasi kacau. Solusinya adalah pin XSHUT: selama XSHUT LOW, sensor mati total dan tidak terlihat di bus I2C. Ketika mulai, kamu membangunkan sensor satu per satu dan memberi masing-masing alamat baru lewat software. Alamat baru hanya berlaku sampai daya terputus atau XSHUT kembali LOW, jadi langkah ini dilakukan di setup() setiap kali menyala. Dengan cara ini mudah memasang tiga sensor di robot, kiri, tengah, dan kanan; dalam praktik batasnya adalah jumlah pin digital yang tersisa dan panjang total kabel.
- Sambungkan pin VIN, GND, SDA, dan SCL semua sensor ke bus bersama; sambungkan pin XSHUT tiap sensor ke pin digital terpisah (D4 dan D5 di contoh).
- Di awal setup(), buat semua pin XSHUT LOW untuk mematikan semua sensor.
- Bangunkan sensor 1, mulai dengan init(), lalu beri alamat barunya dengan setAddress(0x30).
- Bangunkan sensor 2, mulai, lalu beri alamat 0x31; kalau ada sensor lain, lanjutkan dengan 0x32, 0x33, dan seterusnya.
- Mulai pengukuran kontinu di semua sensor dan baca masing-masing lewat objeknya sendiri.
1#include <Wire.h>
2#include <VL53L0X.h>
3
4const uint8_t XSHUT_1 = 4;
5const uint8_t XSHUT_2 = 5;
6
7VL53L0X sensor1;
8VL53L0X sensor2;
9
10void setup() {
11 Serial.begin(115200);
12 Wire.begin();
13
14 pinMode(XSHUT_1, OUTPUT);
15 pinMode(XSHUT_2, OUTPUT);
16 digitalWrite(XSHUT_1, LOW); // iki sensörü de kapat / shut down both sensors
17 digitalWrite(XSHUT_2, LOW);
18 delay(10);
19
20 pinMode(XSHUT_1, INPUT); // 1. sensörü aç, modülün pull-up direnci HIGH yapar / wake sensor 1, module pull-up pulls it HIGH
21 delay(10);
22 sensor1.setTimeout(500);
23 if (!sensor1.init()) {
24 Serial.println(F("Sensor 1 yok / Sensor 1 missing"));
25 while (1) {}
26 }
27 sensor1.setAddress(0x30); // yeni adres / new address
28
29 pinMode(XSHUT_2, INPUT); // 2. sensörü aç / wake sensor 2
30 delay(10);
31 sensor2.setTimeout(500);
32 if (!sensor2.init()) {
33 Serial.println(F("Sensor 2 yok / Sensor 2 missing"));
34 while (1) {}
35 }
36 sensor2.setAddress(0x31);
37
38 sensor1.startContinuous();
39 sensor2.startContinuous();
40}
41
42void loop() {
43 Serial.print(F("Sol / Left: "));
44 Serial.print(sensor1.readRangeContinuousMillimeters());
45 Serial.print(F(" mm Sag / Right: "));
46 Serial.print(sensor2.readRangeContinuousMillimeters());
47 Serial.println(F(" mm"));
48 delay(100);
49}VL53L0X dengan ESP32
Di ESP32, library Pololu yang sama bisa dipakai tanpa perubahan. Pin I2C default-nya GPIO 21 (SDA) dan GPIO 22 (SCL); menuliskannya secara eksplisit dengan Wire.begin(21, 22) menghindarkanmu dari kejutan di board yang berbeda. Karena pin ESP32 bekerja di 3,3 V, kamu bisa langsung membuat XSHUT HIGH; cara INPUT yang dipakai di Uno tidak diperlukan. Contoh di bawah mengukur dengan budget 50 ms, merata-ratakan 5 pembacaan terakhir, dan menyalakan LED bawaan board ketika benda mendekat kurang dari 15 cm. Merata-ratakan adalah cara paling sederhana untuk menghaluskan nilai yang melompat-lompat; untuk metode yang lebih canggih, lihat menyaring data sensor. Kalau ingin memantau jarak dari ponselmu, kamu bisa menggabungkan kode ini dengan contoh web server ESP32.
1#include <Wire.h>
2#include <VL53L0X.h>
3
4const int SDA_PIN = 21;
5const int SCL_PIN = 22;
6const int LED_PIN = 2; // çoğu DevKit'te dahili LED / onboard LED on most DevKits
7const uint16_t ESIK_MM = 150; // uyarı eşiği / warning threshold
8const uint8_t N = 5; // ortalama için örnek sayısı / samples for averaging
9
10VL53L0X sensor;
11uint16_t olcumler[N];
12uint8_t sira = 0;
13
14uint16_t olc() {
15 uint16_t mm = sensor.readRangeContinuousMillimeters();
16 if (mm > 2000) mm = 2000; // menzil dışını sınırla / clamp out-of-range values
17 return mm;
18}
19
20void setup() {
21 Serial.begin(115200);
22 pinMode(LED_PIN, OUTPUT);
23 Wire.begin(SDA_PIN, SCL_PIN);
24 Wire.setClock(400000); // hızlı I2C / fast-mode I2C
25 sensor.setTimeout(500);
26 if (!sensor.init()) {
27 Serial.println("VL53L0X bulunamadi / not found");
28 while (true) delay(1000);
29 }
30 sensor.setMeasurementTimingBudget(50000); // 50 ms bütçe / 50 ms budget
31 sensor.startContinuous();
32 for (uint8_t i = 0; i < N; i++) olcumler[i] = olc(); // diziyi doldur / pre-fill the buffer
33}
34
35void loop() {
36 uint16_t mm = olc();
37 if (sensor.timeoutOccurred()) {
38 Serial.println("Zaman asimi / Timeout");
39 return;
40 }
41 olcumler[sira] = mm;
42 sira = (sira + 1) % N;
43
44 uint32_t toplam = 0;
45 for (uint8_t i = 0; i < N; i++) toplam += olcumler[i];
46 uint16_t ortalama = toplam / N;
47
48 digitalWrite(LED_PIN, ortalama < ESIK_MM ? HIGH : LOW);
49 Serial.printf("Ham / Raw: %u mm Ortalama / Average: %u mm\n", (unsigned)mm, (unsigned)ortalama);
50 delay(50);
51}Raspberry Pi Pico dan VL53L0X dengan MicroPython
MicroPython tidak punya modul bawaan untuk VL53L0X; kamu perlu menyalin file driver vl53l0x.py buatan komunitas ke Pico dengan Thonny. Driver ini memindahkan urutan inisialisasi dari ST ke Python dan biasanya menyediakan fungsi start(), read(), dan stop(); cek sekali nama fungsi di file driver yang kamu pakai. Untuk pengkabelan kita memakai I2C0 di GP4 (SDA) dan GP5 (SCL); hasil scan seharusnya menampilkan 0x29 (41 dalam desimal). Ekspresi Pin("LED") di kode memilih LED bawaan di Pico maupun Pico W pada MicroPython 1.20 ke atas. Logika XSHUT yang sama berlaku ketika memakai beberapa sensor di Pico; karena Pico bekerja di 3,3 V, kamu bisa langsung membuat pin XSHUT HIGH. Kalau kamu baru mengenal MicroPython, lihat dulu dasar-dasar MicroPython.
1from machine import Pin, I2C
2import time
3from vl53l0x import VL53L0X # vl53l0x.py Pico'da olmalı / must be on the Pico
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
6print("I2C:", [hex(a) for a in i2c.scan()]) # 0x29 görmelisin / you should see 0x29
7
8tof = VL53L0X(i2c) # varsayılan adres 0x29 / default address 0x29
9led = Pin("LED", Pin.OUT) # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
10ESIK_MM = 150 # uyarı eşiği / warning threshold
11
12tof.start() # sürekli ölçüm / continuous ranging
13try:
14 while True:
15 mm = tof.read()
16 if mm > 2000:
17 print("Menzil disi / Out of range")
18 else:
19 print(mm, "mm")
20 led.value(1 if mm < ESIK_MM else 0)
21 time.sleep_ms(100)
22finally:
23 tof.stop() # ölçümü durdur / stop rangingTips agar pengukuran akurat
- Warna target berpengaruh: Permukaan putih dan doff memantulkan cahaya dengan baik; di permukaan hitam, abu-abu gelap, atau seperti beludru, jangkauan bisa turun jadi setengah atau kurang.
- Hindari sinar matahari: Sinar matahari punya komponen inframerah yang kuat dan menaikkan derau latar sensor. Di luar ruangan, taruh sensor di tempat teduh atau pilih HC-SR04.
- Hati-hati dengan kaca penutup: Kalau kamu menaruh sensor di dalam kotak, kaca atau akrilik di depannya memantulkan sebagian cahaya kembali (crosstalk) dan membuat hasil terbaca terlalu pendek. Kalau butuh penutup, pilih bahan tipis yang tembus inframerah dan sedekat mungkin dengan sensor.
- Permukaan mengilap seperti cermin: Cahaya bisa memantul dari permukaan mengilap yang miring ke arah lain; usahakan sensor setegak lurus mungkin terhadap permukaan.
- Target kecil: Kerucut 25 derajat melebar seiring jarak; di 1 meter ia melihat area berdiameter sekitar 44 cm. Ketika mengukur benda kecil dari jauh, dinding di belakangnya juga bisa ikut memengaruhi hasil.
- Jaga kabel tetap pendek: Bus I2C memburuk di kabel panjang; untuk sambungan lebih dari 30 cm, turunkan kecepatan ke 100 kHz dan jauhkan kabel dari kabel motor.
Ide proyek dengan VL53L0X
- Asisten parkir garasi: Ukur jarak mobil ke dinding dan ubah warna LED seiring makin dekat. Untuk contoh lengkap, lihat artikel sistem parkir Arduino.
- Tempat sampah atau dispenser sabun tanpa sentuh: Biarkan servo membuka tutup ketika tanganmu mendekat dalam 10 cm; di proyek tempat sampah pintar kamu bisa memakai VL53L0X sebagai pengganti HC-SR04.
- Robot penghindar rintangan bermata tiga: Pasang satu sensor di kiri, tengah, dan kanan, lalu taruh di satu bus dengan XSHUT; robot penghindar rintangan jadi berbelok jauh lebih cerdas.
- Indikator level pakan hewan atau biji-bijian: Pasang di tutup corong dan tampilkan sisa isinya dalam persen; cocok dipadukan dengan proyek pemberi pakan hewan otomatis.
- Dimmer dengan gerakan tangan: Ubah jarak tanganmu ke sensor menjadi kecerahan LED dengan PWM; misalnya 5 cm terang penuh dan 30 cm mati.
- Penggaris digital: Tampilkan jarak terukur dengan angka besar di layar OLED dan jadikan alat ukur meja.
Kesalahan umum dan cara mengatasinya
| Gejala | Kemungkinan penyebab | Solusi |
|---|---|---|
| init() mengembalikan false, sensor tidak ditemukan | SDA dan SCL tertukar, tidak ada daya, atau pin salah | Cari alamat 0x29 dengan I2C scanner; cek bahwa di Uno SDA = A4 dan SCL = A5 |
| Nilai tertahan di sekitar 8190 | Target di luar jangkauan, selotip pelindung belum dilepas, atau permukaan terlalu gelap | Lepas selotipnya, dekatkan target, coba profil jarak jauh |
| Pengukuran meleset beberapa sentimeter | Offset modul atau ada kaca penutup di depannya | Ukur di jarak yang diketahui dan kurangi selisihnya di kode; lepas atau ganti penutupnya |
| Nilai terus melompat-lompat | Timing budget pendek, cahaya sekitar, target kecil | Naikkan budget ke 50–200 ms, rata-ratakan beberapa pembacaan |
| 65535 dan pesan timeout | Kabel I2C panjang atau longgar, sensor ter-reset | Perpendek kabel, kencangkan sambungan, restart sensor |
| Salah satu dari dua sensor sama sekali tidak merespons | Alamat bentrok atau sambungan XSHUT tidak ada | Cek pin XSHUT, bangunkan sensor bergiliran dan beri alamat yang berbeda |
| Pembacaan terlalu pendek di luar ruangan | Derau inframerah dari sinar matahari | Taruh sensor di tempat teduh, pakai profil akurasi tinggi, atau beralih ke HC-SR04 |
Dengan ukurannya yang kecil, sudut pandang sempit, dan resolusi milimeter, VL53L0X menambahkan mata yang presisi ke berbagai proyek, dari robot sampai sakelar tanpa sentuh; begitu kamu memilih profil yang tepat dan mengoreksi offset-nya, kamu mendapat hasil yang jauh lebih stabil di jarak pendek, tempat sensor ultrasonik kesulitan. Di aplikasi BlueGrays kamu bisa menjelajahi proyek pengukur jarak, sensor parkir, pengukur tinggi badan, dan robot penghindar rintangan lengkap dengan skema rangkaian dan kode langkah demi langkah, lalu dengan mudah menerapkan logika yang sama ke proyekmu sendiri dengan VL53L0X.
Pertanyaan umum
Seberapa jauh VL53L0X bisa mengukur?
Dengan pengaturan default, jangkauan yang andal sekitar 1,2 meter. Di profil jarak jauh, di lingkungan gelap, dan dengan target putih yang memantulkan cahaya dengan baik, ia bisa mengukur sampai 2 meter. Di permukaan abu-abu atau gelap dan di bawah sinar matahari, jangkauan ini turun cukup jauh.
Mana yang lebih bagus, VL53L0X atau HC-SR04?
Tergantung di mana kamu memakainya. VL53L0X kecil, bersudut sempit, dan lebih stabil di bawah 2 meter, dan berkat I2C beberapa sensor mudah disambung di satu bus. HC-SR04 mengukur sampai 4 meter, tidak terpengaruh sinar matahari, dan bisa mendeteksi kaca, tapi kesulitan dengan permukaan lunak seperti kain.
Berapa alamat I2C VL53L0X dan bagaimana cara mengubahnya?
Alamat default 7-bit-nya 0x29; dalam notasi 8-bit juga ditulis 0x52. Kamu mengubah alamat lewat software dengan setAddress(), tapi tidak permanen; alamat kembali ke 0x29 ketika daya terputus atau XSHUT menjadi LOW. Dengan beberapa sensor, kamu perlu membangunkannya bergiliran dengan XSHUT dan memberi alamat setiap kali menyala.
Kenapa VL53L0X menampilkan 8190?
Library Pololu mengembalikan nilai seperti 8190 atau 8191 ketika sensor tidak menemukan pantulan valid di sudut pandangnya. Target mungkin di luar jangkauan, permukaannya terlalu gelap, atau selotip pelindung di sensor belum dilepas. Nilai 65535 berarti timeout I2C; cek kabel dan catu dayanya.
Apakah VL53L0X bekerja di bawah sinar matahari?
Bekerja, tapi performanya turun. Sinar matahari mengandung komponen inframerah yang kuat, yang menaikkan derau latar sensor dan bisa memangkas jangkauan jadi setengah atau kurang. Menaruh sensor di tempat teduh ketika di luar ruangan, memilih profil akurasi tinggi, dan memakainya di jarak pendek semuanya membantu.
Apa bedanya VL53L0X dan VL53L1X?
VL53L1X adalah anggota yang lebih baru dari keluarga yang sama; ia mengukur sampai 4 meter dan memungkinkanmu memilih hanya sebagian sudut pandang (ROI). VL53L0X terbatas 2 meter, tapi lebih murah dan lebih dari cukup untuk proyek jarak pendek. Kedua sensor memakai library yang berbeda, jadi kodenya tidak bisa dipindahkan begitu saja.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
Pengukuran Jarak HC-SR04 (Tampilan Serial)
Sensor HC-SR04 bekerja persis seperti kelelawar yang mencari jalan dalam gelap: ia mengirim suara yang tidak bisa kamu dengar, mendengarkan pantulannya, dan mengukur seberapa jauh benda di depannya.

Sensor Parkir dengan HC-SR04
Versi mini sensor parkir mobil: makin dekat sesuatu, makin cepat bunyi bipnya. Sensor jarak mengukur benda di depannya; jika jaraknya lebih dari 20 sentimeter LED hijau tetap menyala, dan begitu…

Mengukur Jarak dengan Layar LCD
Alat yang mengukur jarak tanpa penggaris: gerakkan tanganmu maju-mundur di depan sensor dan lihat angkanya berubah.

Proyek Pengukur Tinggi Badan
Pengukur tinggi yang digantung di kusen pintu dan memberi tahu, dalam sentimeter, tinggi orang yang berdiri di bawahnya.

Membaca Pantulan (Kedekatan) dengan TCRT5000
Dengan sensor kecil yang memancarkan cahaya tak terlihat dan mengukur berapa banyak yang terpantul kembali, kamu bisa mendeteksi permukaan di depannya.

Robot Penghindar Rintangan
Bagaimana kalau membuat kendaraan pintar yang mencari jalannya sendiri? Robot Penghindar Rintangan terus memindai sekelilingnya berkat sensor ultrasonik di depannya.

Sensor Jarak Ultrasonik HC-SR04 ESP32
Sensor ultrasonik HC-SR04 menghitung jarak dengan mengukur waktu yang dibutuhkan gelombang suara yang dipancarkannya untuk memantul dari benda lalu kembali (Time of Flight). Di proyek ini, kita mengirim pulsa 10 mikrodetik dari ESP32 ke pin TRIG sensor dan membaca durasi pantulan dari pin ECHO dengan pulseIn(). Jarak hasil hitung ditampilkan dalam sentimeter di LCD I2C 16x2. Karena HC-SR04 bekerja di 5V, pembagi tegangan wajib dipasang di pin ECHO.

Sensor Parkir ESP32 (HC-SR04 + Bar 5 LED + Buzzer + OLED)
Versi ESP32 dari sensor parkir mobil! Kita memakai sensor ultrasonik HC-SR04 untuk mengukur jarak ke benda di depannya. Semakin dekat jaraknya, bar 5 LED semakin penuh (hijau → kuning → merah) dan jeda bunyi bip buzzer semakin pendek. Ketika benda sudah sangat dekat (di bawah 10 cm), alarm berbunyi terus dan semua LED menyala. Layar OLED SSD1306 menampilkan jarak terkini dalam cm dengan font besar, pesan status (STOP / CAUTION / CLOSE / STOP! / DANGER), dan simulasi bar jarak.
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

