Gidsen · 10 min leestijd

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.

HC-SR04 ultrasone afstandssensor
HC-SR04: twee ultrasone transducers, één die geluid uitzendt en één die luistert naar de echo; de meest gebruikte afstandssensor in de Arduino-wereld.

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.

PrincipeSensorenVoordelenNadelen
Time of flight met geluidHC-SR04, JSN-SR04TGoedkoop, niet gevoelig voor kleur en lichtBrede bundel, zwak op zachte en schuine oppervlakken, temperatuurgevoelig
Time of flight met lichtVL53L0X, VL53L1X, TF-LunaSnel, smalle bundel, goede nauwkeurigheidZonlicht en glas geven problemen
Infrarood-triangulatieSharp GP2Y0A21Weinig invloed van kleur, eenvoudige analoge uitgangNiet-lineaire uitgang, klein bereik, misleidend onder 10 cm
Reflectie-intensiteitTCRT5000Zeer goedkoop, zeer snelSlechts 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.

SensorBereikNauwkeurigheidBundelhoekInterfaceVoedingRelatieve prijs
HC-SR042–400 cmOngeveer ±0,3–1 cmOngeveer 15°Trig/Echo-puls5 V (HC-SR04P: 3,3–5 V)Zeer goedkoop
JSN-SR04TOngeveer 25–450 cmOngeveer ±1 cmBreed (ongeveer 45° of meer)Trig/Echo, bij sommige versies UART5 VGoedkoop
Sharp GP2Y0A2110–80 cmGoed dichtbij, zwak verafSmal (enkele graden)Analoge spanning4,5–5,5 VGemiddeld
VL53L0X3 cm – 2 m (standaard ~1,2 m)Ongeveer ±3%25°I2C (0x29)Module 3,3–5 VGoedkoop
VL53L1X4 cm – 4 mOngeveer ±3%, resolutie in mm27° (te verkleinen tot 15°)I2C (0x29)Module 3,3–5 VGemiddeld
TF-Luna0,2–8 m±6 cm (tot 3 m), ±2% (3–8 m)2°UART of I2C5 V, 3,3 V-logicaDuur
TCRT5000Ongeveer 0,2–15 mm (beste bij 2,5 mm)Geen afstand, wel aanwezig/afwezigSmalDigitaal (DO) + analoog (AO)3,3–5 VZeer 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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}
38
Ladders, leidingen of vlotters in de tank kunnen door de brede bundel echo's terugsturen; plaats de sensor uit hun buurt, dicht bij het midden van de tank. Als er condensdruppels op de transducer komen, gaan de metingen fout; door de sensor onder een lichte hoek te monteren kunnen de druppels afglijden. Als het wateroppervlak rimpelt, gebruik dan de mediaan van meerdere metingen.

Sharp 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.

C++ (Arduino IDE)
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}
27

Sharp-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.

C++ (Arduino IDE)
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}
33

Het 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.

C++ (Arduino IDE)
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}
44

TCRT5000: nabijheids- en lijndetectie

TCRT5000 infrarood reflectiesensor
TCRT5000: een infrarood-led en een fototransistor naast elkaar; de modulekaart heeft een comparator, een drempelpotmeter en digitale en analoge uitgangen.

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.

C++ (Arduino IDE)
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}
20

Invloed 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 / omgevingUltrasoon (HC-SR04)Sharp IRLaser-ToF (VL53, TF-Luna)TCRT5000
Harde, vlakke muurZeer goedGoedZeer goedGoed (alleen heel dichtbij)
Stof, schuim, gordijnenZwak (geluid wordt geabsorbeerd)GoedGoedGemiddeld
Mat zwart oppervlakGoedGemiddeldBereik wordt korterZeer zwak
Glas, spiegel, glanzend metaalGoed (geluid weerkaatst)MisleidendMisleidend (licht gaat erdoorheen of buigt af)Misleidend
Schuin oppervlakZwak (echo buigt af)GemiddeldGoedGemiddeld
Zonlicht, buitenGeen invloedBeïnvloedBereik daalt merkbaarBeïnvloed
WateroppervlakGoed (tankmeting)ZwakWisselendNiet geschikt
TemperatuurveranderingenGeluidssnelheid verandert, correctie nodigWeinig invloedWeinig invloedWeinig invloed

Bedradingsoverzicht: Uno, ESP32 en Pico

SensorArduino UnoESP32Raspberry Pi PicoOpmerking
HC-SR04 / JSN-SR04TTRIG D9, ECHO D10, 5VTRIG 5, ECHO 18 (via spanningsdeler), VIN 5VTRIG GP14, ECHO GP15 (via spanningsdeler), VBUSECHO geeft 5 V af
Sharp GP2Y0A21A0, 5VGPIO 34 (via spanningsdeler), VIN 5VGP26 (via spanningsdeler), VBUSUitgang kan 3,1 V bereiken
VL53L0X / VL53L1XSDA A4, SCL A5SDA 21, SCL 22SDA GP4, SCL GP5Adres 0x29
TF-LunaSoftwareSerial wordt afgeradenTX → GPIO 16, RX → GPIO 17TX → GP1 (uart0 RX), RX → GP05 V-voeding, 3,3 V-logica
TCRT5000-moduleDO D7, AO A1DO 27, AO 34DO GP16, AO GP273,3–5 V
Als je de uitgangen van sensoren met 5 V-voeding (HC-SR04 ECHO, analoge uitgang van de Sharp) op een ESP32 of Pico aansluit, vergeet dan de spanningsdeler niet; de pinnen van deze boards zijn niet 5V-tolerant. Omdat de uitgang van de Sharp 3,1 V kan bereiken, brengt hij een ADC met 3,3 V-referentie aan zijn limiet; meten via een deler zoals 10 kΩ + 20 kΩ en het resultaat met 1,5 vermenigvuldigen is veiliger.

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.

MicroPython
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)
23

Welke afstandssensor voor welk project?

ProjectAanbevolen sensorWaarom?
Robot die obstakels ontwijktHC-SR04 (budget) of VL53L0XDe brede bundel mist geen obstakels; de VL53L0X is sneller en kleiner
Waterpeil in tank of putJSN-SR04TWaterdichte probe, ziet het wateroppervlak goed
Parkeersensor voor autoJSN-SR04T of HC-SR04Duurzaam buiten, bereik van 2–3 m is genoeg
LijnvolgrobotTCRT5000Gemaakt om zwart van wit te onderscheiden
Minisumo, nauwkeurige meting op je bureauVL53L0X / VL53L1XResolutie in millimeters, smalle bundel, klein formaat
Arduino-radar (servo-sweep)HC-SR04 of TF-LunaDe HC-SR04 is goedkoop; de bundel van 2° van de TF-Luna tekent een veel scherpere kaart
Lengtemeter, deurtellingVL53L1X of TF-LunaGroot bereik en stabiele metingen
Drone, grote afstandTF-LunaBereik van 8 m, tot 250 Hz
Aanraakloze kraan, handdetectieSharp GP2Y0A21Bereik 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

SymptoomWaarschijnlijke oorzaakOplossing
HC-SR04 geeft altijd 0 of buiten bereikGeen echo, probleem met bedrading of voedingControleer de 5 V-voeding en de TRIG/ECHO-pinnen, geef pulseIn een timeout
Ultrasone metingen springen af en toeEcho van de vorige puls of van een zijmuurWacht 60 ms tussen metingen, gebruik een mediaanfilter
JSN-SR04T kan dichtbij niet metenDode zone (20–25 cm)Monteer de sensor minstens 25 cm van het doel
Sharp geeft heel dichtbij een grote, foute waardeDe kromme klapt terug onder 10 cmZorg dat het doel niet dichterbij dan 10 cm kan komen
Metingen van de Sharp zijn ruisigStroompulsen verstoren de voedingCondensator van 10 µF over VCC-GND, metingen middelen
VL53L0X niet gevondenI2C-bedrading of adresconflictControleer SDA/SCL en adres 0x29 met een I2C-scanner
Lasersensor meet buiten te kortInfrarood in zonlichtZorg voor schaduw, verhoog het timingbudget of gebruik ultrasoon
Data van de TF-Luna is onzinVerkeerde baudrate of SoftwareSerial kan het niet bijhoudenGebruik 115200 baud en een hardware-UART, controleer de checksum
Denk voordat je een sensor kiest aan het doel: voor een groot, hard doel dichtbij is een HC-SR04 meestal genoeg. Als je een smalle plek nauwkeurig moet meten of zachte oppervlakken wilt zien, stap dan over op ToF; voor vochtige of buitenplekken de JSN-SR04T; en als je meer dan een paar meter of zeer snelle metingen nodig hebt, de TF-Luna.

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.

Alle projecten bekijken
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

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.

4.6(50)
82
Parkeersensor met HC-SR04
AR-28Gemiddeld
Premium

Parkeersensor met HC-SR04

Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

4.8(64)
86
Lengtemeetproject
AR-33Gemiddeld
Premium

Lengtemeetproject

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

4.5(25)
34
Obstakelvermijdende robot
AR-81Gevorderd
Premium

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.

5.0(38)
49
ESP32 HC-SR04 ultrasone afstandssensor
ES-14Gemiddeld

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.

4.9(29)
48
ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)
ES-38Gevorderd
Premium

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.

14
Reflectie (nabijheid) meten met de TCRT5000
AR-77Gemiddeld
Premium

Reflectie (nabijheid) meten met de TCRT5000

Met een kleine sensor die onzichtbaar licht uitzendt en meet hoeveel er terugkaatst, detecteer je het oppervlak ervoor.

4.6(33)
43
Afstand meten met een lcd-scherm
AR-31Gevorderd
Premium

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.

4.6(45)
59