Afstandssensoren voor Arduino: HC-SR04, IR, VL53L0X en LiDAR
Afstandssensoren voor Arduino vergeleken: HC-SR04, JSN-SR04T, Sharp IR, VL53L0X/VL53L1X, TF-Luna en TCRT5000; bereik, nauwkeurigheid, bundelhoek, oppervlakken en voorbeeldcode.
Kiezen tussen afstandssensoren voor Arduino lijkt in eerste instantie een kwestie van "welke meet het verst", maar wat echt de doorslag geeft is het oppervlak dat je meet, de nauwkeurigheid die je nodig hebt, hoe smal de bundel moet zijn en de omstandigheden eromheen. Dezelfde HC-SR04 die de afstand tot een muur op de centimeter nauwkeurig meet, kan grillig worden op de zachte stof van een bank, terwijl een goedkope lasersensor met millimeternauwkeurigheid in zonlicht de helft van zijn bereik kan verliezen. In deze gids zetten we de zes sensoren die het meest in Arduino-projecten worden gebruikt naast elkaar.
De sensoren die we vergelijken zijn: de ultrasone HC-SR04 en zijn waterdichte broertje de JSN-SR04T, de infrarood-triangulatiesensor Sharp GP2Y0A21, de laser-time-of-flight-sensoren (ToF) VL53L0X en VL53L1X, de kleine LiDAR TF-Luna en de nabijheidssensor voor korte afstand TCRT5000. Bij elke sensor leggen we het werkingsprincipe, het bereik, de nauwkeurigheid, de bundelhoek, de reactie op oppervlakken en de interface uit, en geven we een gecompileerde voorbeeldsketch. Aan het eind vat een tabel samen welke sensor je voor welk project kiest.

Hoe meten afstandssensoren? Drie basisprincipes
Bijna elke afstandssensor die met Arduino wordt gebruikt, werkt volgens een van drie methoden. Time of flight: de sensor zendt een puls geluid of licht uit en meet hoe lang de weerkaatsing erover doet om terug te komen; de afstand is de helft van tijd maal snelheid. Ultrasone sensoren doen dit met geluid, de VL53L0X en TF-Luna met licht. Omdat licht ongeveer een miljoen keer sneller is dan geluid, bevatten ToF-sensoren speciale chips met timing op picoseconde-niveau. Triangulatie: Sharp IR-sensoren sturen een infraroodbundel naar het doel en kijken waar het gereflecteerde licht landt op een positiegevoelige detector (PSD); bij nabije objecten verschuift de lichtvlek naar het ene uiteinde, bij verre naar het andere. Reflectie-intensiteit: eenvoudige sensoren zoals de TCRT5000 meten alleen hoe sterk het terugkerende licht is; omdat dit sterk van de kleur van het oppervlak afhangt, is het nabijheidsdetectie en geen echte afstandsmeting.
| Principe | Sensoren | Voordelen | Nadelen |
|---|---|---|---|
| Time of flight met geluid | HC-SR04, JSN-SR04T | Goedkoop, niet gevoelig voor kleur en licht | Brede bundel, zwak op zachte en schuine oppervlakken, temperatuurgevoelig |
| Time of flight met licht | VL53L0X, VL53L1X, TF-Luna | Snel, smalle bundel, goede nauwkeurigheid | Zonlicht en glas geven problemen |
| Infrarood-triangulatie | Sharp GP2Y0A21 | Weinig invloed van kleur, eenvoudige analoge uitgang | Niet-lineaire uitgang, klein bereik, misleidend onder 10 cm |
| Reflectie-intensiteit | TCRT5000 | Zeer goedkoop, zeer snel | Slechts enkele mm tot cm, sterk kleurafhankelijk |
De grote vergelijkingstabel
De tabel hieronder brengt de typische waarden van de modules voor elke sensor samen. De bereiken zijn de opgaven van de fabrikanten; in een echt project kunnen ze korter zijn, afhankelijk van het oppervlak en de omgeving. Prijzen verschillen per land, daarom staan ze in relatieve termen.
| Sensor | Bereik | Nauwkeurigheid | Bundelhoek | Interface | Voeding | Relatieve prijs |
|---|---|---|---|---|---|---|
| HC-SR04 | 2–400 cm | Ongeveer ±0,3–1 cm | Ongeveer 15° | Trig/Echo-puls | 5 V (HC-SR04P: 3,3–5 V) | Zeer goedkoop |
| JSN-SR04T | Ongeveer 25–450 cm | Ongeveer ±1 cm | Breed (ongeveer 45° of meer) | Trig/Echo, bij sommige versies UART | 5 V | Goedkoop |
| Sharp GP2Y0A21 | 10–80 cm | Goed dichtbij, zwak veraf | Smal (enkele graden) | Analoge spanning | 4,5–5,5 V | Gemiddeld |
| VL53L0X | 3 cm – 2 m (standaard ~1,2 m) | Ongeveer ±3% | 25° | I2C (0x29) | Module 3,3–5 V | Goedkoop |
| VL53L1X | 4 cm – 4 m | Ongeveer ±3%, resolutie in mm | 27° (te verkleinen tot 15°) | I2C (0x29) | Module 3,3–5 V | Gemiddeld |
| TF-Luna | 0,2–8 m | ±6 cm (tot 3 m), ±2% (3–8 m) | 2° | UART of I2C | 5 V, 3,3 V-logica | Duur |
| TCRT5000 | Ongeveer 0,2–15 mm (beste bij 2,5 mm) | Geen afstand, wel aanwezig/afwezig | Smal | Digitaal (DO) + analoog (AO) | 3,3–5 V | Zeer goedkoop |
HC-SR04: de ultrasone klassieker
De HC-SR04 zendt acht ultrasone geluidspulsen van 40 kHz uit en houdt zijn ECHO-pin HIGH totdat de echo terugkomt. De Arduino meet de lengte van deze puls in microseconden met pulseIn(). Bij 20 °C legt geluid ongeveer 343 meter per seconde af, oftewel 0,0343 cm per microseconde; omdat het geluid naar het doel en terug gaat, geldt afstand = tijd × 0.0343 / 2. De geluidssnelheid verandert met de temperatuur (ongeveer 331.3 + 0.606 × T m/s): tussen 0 °C en 35 °C zit een verschil van ongeveer 6%, wat bij 2 meter tot 12 cm fout kan oplopen. De code hieronder past deze correctie toe en neemt de mediaan van vijf metingen om af en toe een slechte echo eruit te filteren.
1const int TRIG_PIN = 9;
2const int ECHO_PIN = 10;
3const float SICAKLIK = 20.0; // ortam sıcaklığı, °C / ambient temperature, °C
4float sesHizi; // cm/µs
5
6float mesafeOlc() {
7 digitalWrite(TRIG_PIN, LOW);
8 delayMicroseconds(2);
9 digitalWrite(TRIG_PIN, HIGH); // 10 µs tetik darbesi / 10 µs trigger pulse
10 delayMicroseconds(10);
11 digitalWrite(TRIG_PIN, LOW);
12 unsigned long sure = pulseIn(ECHO_PIN, HIGH, 30000UL); // 30 ms ≈ 5 m sınırı / ~5 m limit
13 if (sure == 0) return -1; // yankı yok / no echo
14 return sure * sesHizi / 2.0; // gidiş-dönüş / round trip
15}
16
17void setup() {
18 Serial.begin(9600);
19 pinMode(TRIG_PIN, OUTPUT);
20 pinMode(ECHO_PIN, INPUT);
21 sesHizi = (331.3 + 0.606 * SICAKLIK) / 10000.0; // m/s -> cm/µs (20 °C: 0,0343)
22}
23
24void loop() {
25 float olcum[5];
26 for (int i = 0; i < 5; i++) { // 5 ölçüm, aralarında 60 ms / 5 readings, 60 ms apart
27 olcum[i] = mesafeOlc();
28 delay(60);
29 }
30 for (int i = 1; i < 5; i++) { // sırala / sort
31 float x = olcum[i];
32 int j = i - 1;
33 while (j >= 0 && olcum[j] > x) { olcum[j + 1] = olcum[j]; j--; }
34 olcum[j + 1] = x;
35 }
36 float d = olcum[2]; // ortanca / median
37 if (d < 0) Serial.println("Menzil disi / out of range");
38 else { Serial.print(d, 1); Serial.println(" cm"); }
39}
40- Wacht minstens 60 ms tussen metingen: als je opnieuw meet terwijl er nog echo's van de vorige puls door de ruimte kaatsen, krijg je verkeerde resultaten.
- Zachte en schuine oppervlakken: stof, schuim en gordijnen absorberen geluid; oppervlakken die meer dan 45 graden gekanteld zijn, kaatsen de echo weg van de sensor.
- Brede bundel: de kegel van ongeveer 15 graden beslaat op 2 meter een gebied van bijna 50 cm breed; in een smalle gang kan hij ook de zijmuren zien.
- 3,3 V-boards: de klassieke HC-SR04 heeft 5 V nodig en zijn ECHO-uitgang is 5 V; zet op de ESP32 en Pico een spanningsdeler op ECHO of gebruik de HC-SR04P, die op 3,3 V werkt.
- Meerdere sensoren: twee HC-SR04's die tegelijk worden getriggerd, horen elkaars echo's; trigger ze na elkaar.
Het aansluiten van de HC-SR04 en het gebruik met de Serial Monitor en een LCD worden uitgebreid behandeld in het bericht HC-SR04-afstandssensor; hier richten we ons op de vergelijking.
JSN-SR04T: de waterdichte ultrasone sensor
De JSN-SR04T werkt met dezelfde trigger- en echologica als de HC-SR04, maar zijn transducer zit in een waterdichte capsule aan een kabel, los van de elektronicaprint. Daardoor is hij de keuze voor vochtige plekken zoals watertanks, putten, regenwatertonnen en buitenparkeersensoren. Er zijn twee belangrijke verschillen: omdat één transducer zowel zendt als luistert, is er op korte afstand een dode zone (ongeveer 20–25 cm), en zijn bundel is breder dan die van de HC-SR04. Monteer de sensor op het bovenste deksel van de tank, minstens 25 cm boven het hoogste waterpeil. De code hieronder zet de afstand om in een vulpercentage.
1// JSN-SR04T ile su deposu doluluğu / water tank level with a JSN-SR04T
2const int TRIG_PIN = 9;
3const int ECHO_PIN = 10;
4const float SENSOR_BOSLUK = 25.0; // sensörden en yüksek su seviyesine, cm (ölü bölge) / sensor to max level (blind zone)
5const float DEPO_DERINLIK = 120.0; // en yüksek seviyeden depo dibine, cm / max level to tank bottom
6
7float mesafeOlc() {
8 digitalWrite(TRIG_PIN, LOW);
9 delayMicroseconds(5);
10 digitalWrite(TRIG_PIN, HIGH);
11 delayMicroseconds(20); // JSN-SR04T 10 µs'den uzun darbeyi sever / likes a longer pulse
12 digitalWrite(TRIG_PIN, LOW);
13 unsigned long sure = pulseIn(ECHO_PIN, HIGH, 40000UL);
14 if (sure == 0) return -1;
15 return sure * 0.0343 / 2.0; // 20 °C ses hızı / speed of sound at 20 °C
16}
17
18void setup() {
19 Serial.begin(9600);
20 pinMode(TRIG_PIN, OUTPUT);
21 pinMode(ECHO_PIN, INPUT);
22}
23
24void loop() {
25 float d = mesafeOlc();
26 if (d < 0) {
27 Serial.println("Yanki yok / no echo");
28 } else {
29 float suYuksekligi = DEPO_DERINLIK - (d - SENSOR_BOSLUK); // dipten su yüksekliği / water height
30 float yuzde = constrain(suYuksekligi / DEPO_DERINLIK * 100.0, 0, 100);
31 Serial.print("Mesafe / distance: ");
32 Serial.print(d, 1);
33 Serial.print(" cm Doluluk / fill: %");
34 Serial.println(yuzde, 0);
35 }
36 delay(1000); // su yüzeyi dalgalanır, sık ölçme / water ripples, measure slowly
37}
38Sharp GP2Y0A21: analoog infrarood
De Sharp GP2Y0A21YK0F is een infraroodsensor die werkt tussen 10 en 80 cm en een analoge spanning afgeeft die afhangt van de afstand. Omdat hij triangulatie gebruikt, is hij minder gevoelig voor de kleur van het doel dan sensoren op basis van reflectie-intensiteit. Zijn uitgang is niet lineair: hij geeft ongeveer 2,3 V bij 10 cm en 0,4 V bij 80 cm en volgt daartussen een omgekeerde machtskromme. De code zet deze kromme om met de benadering afstand = 29.988 × V^-1.173. De grootste valkuil zit onder 10 cm: naarmate het doel dichterbij komt, daalt de uitgang weer, en een object op 5 cm kan eruitzien alsof het op 20 cm staat. Monteer de sensor zo dat het doel nooit dichterbij dan 10 cm kan komen.
1// Sharp GP2Y0A21YK0F (10–80 cm), analog / analog output
2const int SHARP_PIN = A0;
3
4float sharpCm() {
5 long toplam = 0;
6 for (int i = 0; i < 20; i++) { // 20 okumanın ortalaması / average of 20 readings
7 toplam += analogRead(SHARP_PIN);
8 delay(2);
9 }
10 float volt = toplam / 20.0 * 5.0 / 1023.0;
11 if (volt < 0.35) return -1; // 80 cm'den uzak / farther than 80 cm
12 float cm = 29.988 * pow(volt, -1.173); // ters güç eğrisi / inverse power curve
13 if (cm > 80) return -1;
14 return cm; // 10 cm altı yanıltıcı / misleading below 10 cm
15}
16
17void setup() {
18 Serial.begin(9600);
19}
20
21void loop() {
22 float cm = sharpCm();
23 if (cm < 0) Serial.println("Menzil disi / out of range");
24 else { Serial.print(cm, 1); Serial.println(" cm"); }
25 delay(100);
26}
27Sharp-sensoren trekken tijdens het meten korte, hoge stroompulsen, en die pulsen veroorzaken ruis op de voedingslijn. Een condensator van ongeveer 10 µF vlak bij de VCC- en GND-pinnen van de sensor maakt de metingen merkbaar rustiger. De familie heeft ook leden met andere bereiken: de GP2Y0A41SK0F werkt van 4 tot 30 cm, de GP2Y0A02YK0F van 20 tot 150 cm; elk heeft andere krommecoëfficiënten.
VL53L0X en VL53L1X: laser-ToF-sensoren
De VL53L0X en VL53L1X zijn piepkleine laser-time-of-flight-sensoren van STMicroelectronics. Ze sturen een onzichtbare laserpuls van 940 nm uit, meten de terugkeertijd van de weerkaatsing met fotonentellers en leveren het resultaat direct in millimeters via I2C. Ze zijn vrijwel onafhankelijk van kleur, hun bundel is smaller dan die van een ultrasone sensor en een meting duurt 20–50 ms. De VL53L0X meet tot ongeveer 1,2 meter in de standaardmodus en 2 meter in de langeafstandsmodus; de VL53L1X haalt 4 meter en zijn gezichtsveld (ROI) kan in software worden verkleind. Beide hebben het standaard I2C-adres 0x29. De code hieronder gebruikt de VL53L0X-bibliotheek van Pololu; zoek in de Library Manager naar "VL53L0X" en installeer de versie van Pololu.
1#include <Wire.h>
2#include <VL53L0X.h> // Pololu VL53L0X kütüphanesi / library
3
4VL53L0X sensor;
5
6void setup() {
7 Serial.begin(9600);
8 Wire.begin(); // Uno: SDA A4, SCL A5 / ESP32: SDA 21, SCL 22
9 sensor.setTimeout(500);
10 if (!sensor.init()) {
11 Serial.println("VL53L0X bulunamadi / not found");
12 while (true) {}
13 }
14 // Uzun menzil modu (2 m'ye kadar, daha gürültülü) / long range mode (up to 2 m, noisier):
15 // sensor.setSignalRateLimit(0.1);
16 // sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
17 // sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
18 sensor.setMeasurementTimingBudget(50000); // 50 ms: daha kararlı ölçüm / steadier reading
19 sensor.startContinuous();
20}
21
22void loop() {
23 uint16_t mm = sensor.readRangeContinuousMillimeters();
24 if (sensor.timeoutOccurred()) {
25 Serial.println("Zaman asimi / timeout");
26 } else if (mm >= 8190) { // 8190-8191: hedef yok / no target
27 Serial.println("Menzil disi / out of range");
28 } else {
29 Serial.print(mm);
30 Serial.println(" mm");
31 }
32}
33Het meettijdbudget (measurement timing budget) bepaalt de balans tussen nauwkeurigheid en snelheid: 20 ms is snel maar ruisig, 200 ms traag maar stabiel. Zonlicht en sterke infraroodbronnen verkorten het bereik merkbaar; houd daar rekening mee als je buiten gaat meten. Om twee VL53L0X'en op dezelfde I2C-bus aan te sluiten, houd je er, omdat beide adres 0x29 hebben, een uitgeschakeld via de XSHUT-pin en geef je de andere een nieuw adres (setAddress); details over I2C staan in het bericht Wat is I2C.
TF-Luna: 8 meter met een kleine LiDAR
De TF-Luna is de kleine enkelpunts-LiDAR van Benewake: hij meet de time of flight door infraroodlicht van 850 nm te moduleren, werkt van 0,2 tot 8 meter met een zeer smalle bundel van slechts 2 graden en kan tot 250 metingen per seconde doen. Standaard stuurt hij elke meting via UART op 115200 baud als een pakket van 9 bytes: twee 0x59-headerbytes, afstand (cm), signaalsterkte, interne temperatuur en een checksum. Als de signaalsterkte lager is dan 100 of gelijk aan 65535 (overbelichting), wordt de meting als onbetrouwbaar beschouwd. Hij wordt gevoed met 5 V, maar zijn UART-logicaniveau is 3,3 V, dus hij sluit direct aan op een ESP32. Omdat SoftwareSerial op de Uno bij 115200 baud niet betrouwbaar is, kies je een board met een hardware-UART, zoals de ESP32 of Mega; de logica van het uitlezen van UART-pakketten wordt uitgelegd in het bericht UART seriële communicatie.
1// TF-Luna LiDAR, UART (115200), ESP32 Serial2
2// TF-Luna TX -> GPIO 16, RX -> GPIO 17, VCC 5V, GND
3const int RXD2 = 16, TXD2 = 17;
4
5uint8_t kare[9]; // 0x59 0x59 DistL DistH AmpL AmpH TempL TempH Checksum
6int konum = 0;
7
8void setup() {
9 Serial.begin(115200);
10 Serial2.begin(115200, SERIAL_8N1, RXD2, TXD2);
11}
12
13void loop() {
14 while (Serial2.available()) {
15 uint8_t b = Serial2.read();
16 if (konum < 2) { // iki 0x59 başlık baytını bekle / wait for two 0x59 header bytes
17 if (b == 0x59) kare[konum++] = b;
18 else konum = 0;
19 continue;
20 }
21 kare[konum++] = b;
22 if (konum < 9) continue;
23 konum = 0;
24
25 uint8_t toplam = 0;
26 for (int i = 0; i < 8; i++) toplam += kare[i];
27 if (toplam != kare[8]) continue; // sağlama toplamı hatalı / bad checksum
28
29 uint16_t mesafe = kare[2] | (kare[3] << 8); // cm
30 uint16_t guc = kare[4] | (kare[5] << 8); // sinyal gücü / signal strength
31 float derece = (kare[6] | (kare[7] << 8)) / 8.0 - 256.0;
32
33 if (guc < 100 || guc == 65535) { // zayıf ya da aşırı sinyal / weak or saturated
34 Serial.println("Guvenilmez / unreliable");
35 } else {
36 Serial.print(mesafe);
37 Serial.print(" cm guc / amp: ");
38 Serial.print(guc);
39 Serial.print(" ic sicaklik / chip temp: ");
40 Serial.println(derece, 1);
41 }
42 }
43}
44TCRT5000: nabijheids- en lijndetectie

De TCRT5000 is geen afstandsmeter maar een reflectiesensor: licht van de infrarood-led kaatst terug van het oppervlak en de fototransistor ernaast meet hoeveel er terugkomt. Hij werkt het best op ongeveer 2,5 mm en het signaal zakt snel weg voorbij 1,5 cm. Omdat witte oppervlakken veel reflecteren en zwarte heel weinig, geeft hij zelfs op dezelfde afstand totaal verschillende waarden afhankelijk van de kleur; daarom wordt hij gebruikt om zwart van wit te onderscheiden in lijnvolgrobots, om gaten in encoderschijven te tellen en om zeer nabije objecten te detecteren. De comparator op de module schakelt de digitale uitgang zodra de met de potmeter ingestelde drempel wordt overschreden. Details staan in het bericht TCRT5000-infraroodsensor.
1// TCRT5000 modülü: DO dijital, AO analog / TCRT5000 module: DO digital, AO analog
2const int DO_PIN = 7;
3const int AO_PIN = A1;
4const int LED_PIN = 13;
5
6void setup() {
7 Serial.begin(9600);
8 pinMode(DO_PIN, INPUT);
9 pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13 bool nesneVar = (digitalRead(DO_PIN) == LOW); // çoğu modülde LOW = yansıma var / LOW = reflection on most modules
14 int yansima = analogRead(AO_PIN); // düşük değer = güçlü yansıma / low value = strong reflection
15 digitalWrite(LED_PIN, nesneVar);
16 Serial.print(nesneVar ? "Nesne VAR / object " : "Nesne yok / none ");
17 Serial.println(yansima);
18 delay(100);
19}
20Invloed van oppervlak en omgeving
Het bereik van een sensor op papier verandert zodra hij het oppervlak tegenkomt dat je meet. Ultrasone sensoren zijn uitstekend op harde oppervlakken die geluid weerkaatsen, maar hebben moeite met stof dat het absorbeert; sensoren op basis van licht letten op kleur, glans en zonlicht. De tabel hieronder laat zien welke sensor in welke situatie betrouwbaar blijft, zodat je dit bij het ontwerp van je project kunt meenemen.
| Oppervlak / omgeving | Ultrasoon (HC-SR04) | Sharp IR | Laser-ToF (VL53, TF-Luna) | TCRT5000 |
|---|---|---|---|---|
| Harde, vlakke muur | Zeer goed | Goed | Zeer goed | Goed (alleen heel dichtbij) |
| Stof, schuim, gordijnen | Zwak (geluid wordt geabsorbeerd) | Goed | Goed | Gemiddeld |
| Mat zwart oppervlak | Goed | Gemiddeld | Bereik wordt korter | Zeer zwak |
| Glas, spiegel, glanzend metaal | Goed (geluid weerkaatst) | Misleidend | Misleidend (licht gaat erdoorheen of buigt af) | Misleidend |
| Schuin oppervlak | Zwak (echo buigt af) | Gemiddeld | Goed | Gemiddeld |
| Zonlicht, buiten | Geen invloed | Beïnvloed | Bereik daalt merkbaar | Beïnvloed |
| Wateroppervlak | Goed (tankmeting) | Zwak | Wisselend | Niet geschikt |
| Temperatuurveranderingen | Geluidssnelheid verandert, correctie nodig | Weinig invloed | Weinig invloed | Weinig invloed |
Bedradingsoverzicht: Uno, ESP32 en Pico
| Sensor | Arduino Uno | ESP32 | Raspberry Pi Pico | Opmerking |
|---|---|---|---|---|
| HC-SR04 / JSN-SR04T | TRIG D9, ECHO D10, 5V | TRIG 5, ECHO 18 (via spanningsdeler), VIN 5V | TRIG GP14, ECHO GP15 (via spanningsdeler), VBUS | ECHO geeft 5 V af |
| Sharp GP2Y0A21 | A0, 5V | GPIO 34 (via spanningsdeler), VIN 5V | GP26 (via spanningsdeler), VBUS | Uitgang kan 3,1 V bereiken |
| VL53L0X / VL53L1X | SDA A4, SCL A5 | SDA 21, SCL 22 | SDA GP4, SCL GP5 | Adres 0x29 |
| TF-Luna | SoftwareSerial wordt afgeraden | TX → GPIO 16, RX → GPIO 17 | TX → GP1 (uart0 RX), RX → GP0 | 5 V-voeding, 3,3 V-logica |
| TCRT5000-module | DO D7, AO A1 | DO 27, AO 34 | DO GP16, AO GP27 | 3,3–5 V |
Ultrasone meting met de Raspberry Pi Pico
In MicroPython meet je de pulslengte met machine.time_pulse_us(); dat doet hetzelfde werk als pulseIn() op de Arduino en geeft bij een timeout een negatieve waarde terug. Voed de HC-SR04 vanuit de VBUS-pin (USB 5 V) van de Pico en zet een deler van 1 kΩ + 2 kΩ op de ECHO-lijn, of gebruik de HC-SR04P, die direct op 3,3 V werkt. Er bestaan ook MicroPython-drivers voor de VL53L0X en TF-Luna; het UART-pakket van de TF-Luna lees je eenvoudig uit met machine.UART, met dezelfde logica als in de Arduino-code.
1from machine import Pin, time_pulse_us
2import time
3
4trig = Pin(14, Pin.OUT)
5echo = Pin(15, Pin.IN) # 5 V ECHO için gerilim bölücü şart / divider required for a 5 V ECHO
6SES_HIZI = 0.0343 # cm/µs, 20 °C
7
8def mesafe_olc():
9 trig.low()
10 time.sleep_us(2)
11 trig.high()
12 time.sleep_us(10) # 10 µs tetik / 10 µs trigger
13 trig.low()
14 sure = time_pulse_us(echo, 1, 30000) # zaman aşımında eksi döner / negative on timeout
15 if sure < 0:
16 return None
17 return sure * SES_HIZI / 2
18
19while True:
20 d = mesafe_olc()
21 print("Menzil disi" if d is None else "{:.1f} cm".format(d))
22 time.sleep_ms(100)
23Welke afstandssensor voor welk project?
| Project | Aanbevolen sensor | Waarom? |
|---|---|---|
| Robot die obstakels ontwijkt | HC-SR04 (budget) of VL53L0X | De brede bundel mist geen obstakels; de VL53L0X is sneller en kleiner |
| Waterpeil in tank of put | JSN-SR04T | Waterdichte probe, ziet het wateroppervlak goed |
| Parkeersensor voor auto | JSN-SR04T of HC-SR04 | Duurzaam buiten, bereik van 2–3 m is genoeg |
| Lijnvolgrobot | TCRT5000 | Gemaakt om zwart van wit te onderscheiden |
| Minisumo, nauwkeurige meting op je bureau | VL53L0X / VL53L1X | Resolutie in millimeters, smalle bundel, klein formaat |
| Arduino-radar (servo-sweep) | HC-SR04 of TF-Luna | De HC-SR04 is goedkoop; de bundel van 2° van de TF-Luna tekent een veel scherpere kaart |
| Lengtemeter, deurtelling | VL53L1X of TF-Luna | Groot bereik en stabiele metingen |
| Drone, grote afstand | TF-Luna | Bereik van 8 m, tot 250 Hz |
| Aanraakloze kraan, handdetectie | Sharp GP2Y0A21 | Bereik van 10–80 cm en eenvoudige analoge uitgang |
Nog een paar projectideeën: zet een HC-SR04 op een servo om een Arduino-radar te bouwen; gebruik een HC-SR04 voorop en twee VL53L0X'en aan de zijkanten van je robot die obstakels ontwijkt; open het deksel van een slimme afvalbak als er een hand nadert; bouw een draagbare digitale meetlint met een OLED-display, of stuur het vulniveau van je watertank met een JSN-SR04T via een ESP32 naar je telefoon.
Veelgemaakte fouten en oplossingen
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| HC-SR04 geeft altijd 0 of buiten bereik | Geen echo, probleem met bedrading of voeding | Controleer de 5 V-voeding en de TRIG/ECHO-pinnen, geef pulseIn een timeout |
| Ultrasone metingen springen af en toe | Echo van de vorige puls of van een zijmuur | Wacht 60 ms tussen metingen, gebruik een mediaanfilter |
| JSN-SR04T kan dichtbij niet meten | Dode zone (20–25 cm) | Monteer de sensor minstens 25 cm van het doel |
| Sharp geeft heel dichtbij een grote, foute waarde | De kromme klapt terug onder 10 cm | Zorg dat het doel niet dichterbij dan 10 cm kan komen |
| Metingen van de Sharp zijn ruisig | Stroompulsen verstoren de voeding | Condensator van 10 µF over VCC-GND, metingen middelen |
| VL53L0X niet gevonden | I2C-bedrading of adresconflict | Controleer SDA/SCL en adres 0x29 met een I2C-scanner |
| Lasersensor meet buiten te kort | Infrarood in zonlicht | Zorg voor schaduw, verhoog het timingbudget of gebruik ultrasoon |
| Data van de TF-Luna is onzin | Verkeerde baudrate of SoftwareSerial kan het niet bijhouden | Gebruik 115200 baud en een hardware-UART, controleer de checksum |
Afstandssensoren zijn de eenvoudigste manier om Arduino-projecten bewust te maken van hun omgeving, en de juiste kiezen maakt het verschil tussen een project dat stabiel draait en een project dat je gek maakt. De tabellen en code in deze vergelijking helpen je om budget en prestaties af te wegen voor jouw wensen. In de BlueGrays-app vind je stap-voor-stap-projecten met schakelschema's en code voor het meten van afstand met een HC-SR04, een parkeersensor, een lengtemeter, een robot die obstakels ontwijkt, een ESP32-parkeersensor en afstandsmeting met een TCRT5000.
Veelgestelde vragen
Wat is de beste afstandssensor voor Arduino?
Er is geen enkele beste sensor; de keuze hangt af van het doel en de omgeving. De HC-SR04 past bij algemeen, goedkoop gebruik, de VL53L0X of VL53L1X bij millimeternauwkeurigheid en een smalle bundel, de JSN-SR04T bij vochtige plekken en de TF-Luna bij snel meten voorbij een paar meter.
Hoe ver kan de HC-SR04 meten?
De opgave van de fabrikant is 2 cm tot 4 meter, maar in de praktijk reiken betrouwbare metingen meestal tot 2–3 meter. Je komt dicht bij de limiet als het doel groot, hard en loodrecht op de sensor is; bij zachte, kleine of schuine doelen krimpt het bereik merkbaar.
Wat is het verschil tussen ultrasone en infrarood-afstandssensoren?
Een ultrasone sensor meet de echotijd van een geluidspuls; hij wordt niet beïnvloed door kleur of licht, maar zijn bundel is breed en hij heeft moeite met zachte oppervlakken. Infraroodsensoren gebruiken licht, hebben smallere bundels en zijn snel, maar zonlicht, glas en sommige donkere oppervlakken kunnen de meting verstoren.
Wat is het verschil tussen de VL53L0X en VL53L1X?
Beide zijn laser-ToF-sensoren met een I2C-interface. De VL53L0X meet tot ongeveer 2 meter, terwijl de VL53L1X 4 meter haalt, sneller kan meten en je zijn gezichtsveld in software laat verkleinen. De VL53L0X past bij kleine robots voor korte afstand, de VL53L1X bij langere en nauwkeurigere metingen.
Welke afstandssensor moet ik gebruiken voor het niveau van een watertank?
De JSN-SR04T met zijn waterdichte probe is de meest gekozen optie; hij wordt op het bovenste deksel van de tank gemonteerd, minstens 25 cm boven het hoogste waterpeil. De HC-SR04 werkt ook in droge, gesloten tanks, maar vocht en condens kunnen hem snel beschadigen.
Werken afstandssensoren met de ESP32 en Raspberry Pi Pico?
Ja, maar je hebt een spanningsdeler nodig om de ECHO-uitgang van de 5 V HC-SR04 en JSN-SR04T en de analoge uitgang van de Sharp terug te brengen naar 3,3 V. VL53L0X-modules en de TF-Luna gebruiken al logica die geschikt is voor 3,3 V, en de HC-SR04P werkt direct op 3,3 V.
Projecten om hierna te bouwen
Alle projecten bekijken
Afstand meten met HC-SR04 (Serial-weergave)
De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

Parkeersensor met HC-SR04
Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

Lengtemeetproject
Een lengtemeter die aan een deurpost hangt en in centimeters laat zien hoe lang de persoon eronder is.

Obstakelvermijdende robot
Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

ESP32 HC-SR04 ultrasone afstandssensor
De ultrasone sensor HC-SR04 meet afstand door te timen hoe lang zijn geluidspuls erover doet om van een voorwerp terug te kaatsen (time of flight). In dit project stuurt de ESP32 een puls van 10 microseconden naar de TRIG-pin en leest hij de echotijd met pulseIn() van de ECHO-pin. De afstand wordt in cm getoond op een 16x2 I2C-LCD. De HC-SR04 werkt op 5V, dus de ECHO-pin heeft een spanningsdeler nodig, anders raakt de 3,3V-GPIO van de ESP32 beschadigd.

ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)
De ESP32-versie van een parkeersensor voor auto's! De HC-SR04-ultrasoonsensor meet de afstand tot het voorwerp ervoor. Naarmate je dichterbij komt, vult een balk van 5 leds zich (groen → geel → rood) en piept de buzzer sneller. Heel dichtbij (onder 10 cm) klinkt een continu alarm en branden alle leds. Het SSD1306 OLED-display toont de live afstand in cm in grote tekst, plus een statusbericht.

Reflectie (nabijheid) meten met de TCRT5000
Met een kleine sensor die onzichtbaar licht uitzendt en meet hoeveel er terugkaatst, detecteer je het oppervlak ervoor.

Afstand meten met een lcd-scherm
Een gereedschap dat afstand meet zonder liniaal: beweeg je hand heen en weer voor de sensor en kijk hoe het getal verandert.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

