Sensori di distanza Arduino: HC-SR04, IR, VL53L0X e LiDAR

Scegliere tra i sensori di distanza per Arduino sembra all'inizio una questione di «quale misura più lontano», ma a decidere davvero sono la superficie da misurare, la precisione necessaria, quanto deve essere stretto il fascio e le condizioni ambientali. Lo stesso HC-SR04 che misura la distanza da un muro al centimetro può diventare instabile sul tessuto morbido di un divano, e un sensore laser economico preciso al millimetro può perdere metà della portata sotto il sole. In questa guida mettiamo fianco a fianco i sei sensori più usati nei progetti Arduino.

I sensori a confronto sono: l'ultrasuoni HC-SR04 e il fratello impermeabile JSN-SR04T, il sensore infrarosso a triangolazione Sharp GP2Y0A21, i sensori laser a tempo di volo (ToF) VL53L0X e VL53L1X, il piccolo LiDAR TF-Luna e il sensore di prossimità a corto raggio TCRT5000. Per ognuno spieghiamo principio di funzionamento, portata, precisione, angolo del fascio, comportamento sulle superfici e interfaccia, con uno sketch di esempio compilato. Alla fine una tabella riassume quale scegliere per quale progetto.

Come misurano i sensori di distanza? Tre principi di base

Quasi tutti i sensori di distanza usati con Arduino si basano su uno di tre metodi. Tempo di volo: il sensore invia un impulso di suono o di luce e misura quanto impiega il riflesso a tornare; la distanza è la metà del prodotto tra tempo e velocità. Gli ultrasuoni lo fanno con il suono, il VL53L0X e il TF-Luna con la luce. Poiché la luce è circa un milione di volte più veloce del suono, i sensori ToF contengono chip speciali che temporizzano al picosecondo. Triangolazione: i sensori Sharp IR inviano un fascio infrarosso sul bersaglio e guardano dove la luce riflessa cade su un rivelatore sensibile alla posizione (PSD); con oggetti vicini il punto si sposta verso un'estremità, con oggetti lontani verso l'altra. Intensità di riflessione: sensori semplici come il TCRT5000 misurano solo quanto è forte la luce che torna; poiché dipende molto dal colore della superficie, è rilevamento di prossimità più che vera misura di distanza.

La grande tabella di confronto

La tabella seguente riunisce i valori tipici dei moduli. Le portate sono quelle dichiarate dai produttori; in un progetto reale possono essere più corte a seconda della superficie e dell'ambiente. Poiché i prezzi cambiano da paese a paese, sono indicati in modo relativo.

HC-SR04: il classico a ultrasuoni

L'HC-SR04 invia otto impulsi sonori a 40 kHz e tiene il pin ECHO a HIGH finché l'eco non torna. Arduino misura la durata di questo impulso in microsecondi con pulseIn(). A 20 °C il suono percorre circa 343 metri al secondo, cioè 0,0343 cm al microsecondo; poiché il suono va al bersaglio e torna, distanza = tempo × 0,0343 / 2. La velocità del suono cambia con la temperatura (circa 331,3 + 0,606 × T m/s): tra 0 °C e 35 °C la differenza è di circa il 6%, cioè fino a 12 cm di errore a 2 metri. Il codice qui sotto applica questa correzione e prende la mediana di cinque misure per scartare qualche eco sbagliato occasionale.

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

• Aspetta almeno 60 ms tra le misure: se misuri di nuovo mentre gli echi dell'impulso precedente rimbalzano ancora nella stanza, ottieni risultati errati.
• Superfici morbide e inclinate: tessuto, gommapiuma e tende assorbono il suono; le superfici inclinate di oltre 45 gradi deviano l'eco lontano dal sensore.
• Fascio largo: il cono di circa 15 gradi copre a 2 metri un'area di quasi 50 cm di diametro; in un corridoio stretto può vedere anche le pareti laterali.
• Schede a 3,3 V: l'HC-SR04 classico vuole 5 V e la sua uscita ECHO è a 5 V; su ESP32 e Pico metti un partitore di tensione su ECHO o usa l'HC-SR04P, che funziona a 3,3 V.
• Più sensori: due HC-SR04 attivati insieme sentono l'uno l'eco dell'altro; attivali uno dopo l'altro.

Il collegamento dell'HC-SR04 e l'uso con il Monitor seriale e un display LCD sono spiegati in dettaglio nell'articolo sensore di distanza HC-SR04; qui ci concentriamo sul confronto.

JSN-SR04T: l'ultrasuoni impermeabile

Il JSN-SR04T funziona con la stessa logica di trigger ed eco dell'HC-SR04, ma il suo trasduttore è in una capsula impermeabile in fondo a un cavo, separata dalla scheda elettronica. Per questo è la scelta per i luoghi umidi come serbatoi d'acqua, pozzi, cisterne per l'acqua piovana e sensori di parcheggio all'aperto. Ha due differenze importanti: poiché un solo trasduttore trasmette e ascolta, c'è una zona cieca a breve distanza (circa 20–25 cm), e il fascio è più largo di quello dell'HC-SR04. Monta il sensore sul coperchio del serbatoio, almeno 25 cm sopra il livello massimo dell'acqua. Il codice qui sotto trasforma la distanza in percentuale di riempimento.

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

Sharp GP2Y0A21: l'infrarosso analogico

Lo Sharp GP2Y0A21YK0F è un sensore infrarosso che lavora tra 10 e 80 cm e fornisce una tensione analogica in base alla distanza. Poiché usa la triangolazione, è meno sensibile al colore del bersaglio rispetto ai sensori basati sull'intensità di riflessione. La sua uscita non è lineare: circa 2,3 V a 10 cm e 0,4 V a 80 cm, con una curva di potenza inversa nel mezzo. Il codice converte la curva con l'approssimazione distanza = 29,988 × V^-1,173. La trappola principale è sotto i 10 cm: quando il bersaglio si avvicina, la tensione torna a scendere e un oggetto a 5 cm può sembrare a 20 cm. Monta il sensore in modo che il bersaglio non possa mai avvicinarsi a meno di 10 cm.

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

I sensori Sharp assorbono brevi picchi di corrente durante la misura, che creano disturbi sull'alimentazione. Un condensatore da circa 10 µF vicino ai pin VCC e GND del sensore calma molto le letture. La famiglia comprende anche modelli con altri campi: il GP2Y0A41SK0F lavora da 4 a 30 cm, il GP2Y0A02YK0F da 20 a 150 cm; ognuno ha coefficienti di curva diversi.

VL53L0X e VL53L1X: sensori laser ToF

VL53L0X e VL53L1X sono minuscoli sensori laser a tempo di volo di STMicroelectronics. Inviano un impulso laser invisibile a 940 nm, misurano con contatori di fotoni il tempo di ritorno del riflesso e forniscono il risultato direttamente in millimetri via I2C. Sono quasi indipendenti dal colore, hanno un fascio più stretto degli ultrasuoni e una misura dura 20–50 ms. Il VL53L0X misura fino a circa 1,2 metri in modalità predefinita e fino a 2 metri in modalità lungo raggio; il VL53L1X arriva a 4 metri e il suo campo visivo (ROI) si può restringere via software. Entrambi hanno l'indirizzo I2C predefinito 0x29. Il codice usa la libreria VL53L0X di Pololu; cerca «VL53L0X» nel Gestore librerie e installa la versione 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}
33

Il budget di tempo di misura (timing budget) regola l'equilibrio tra precisione e velocità: 20 ms è veloce ma rumoroso, 200 ms lento ma stabile. Il sole e le forti sorgenti infrarosse accorciano nettamente la portata; tienine conto se misuri all'aperto. Per collegare due VL53L0X allo stesso bus I2C, dato che entrambi hanno l'indirizzo 0x29, ne tieni spento uno con il pin XSHUT e dai all'altro un nuovo indirizzo (setAddress); i dettagli sull'I2C sono nell'articolo Cos'è l'I2C.

TF-Luna: 8 metri con un piccolo LiDAR

Il TF-Luna è il piccolo LiDAR a punto singolo di Benewake: misura il tempo di volo modulando luce infrarossa a 850 nm, lavora da 0,2 a 8 metri con un fascio strettissimo di soli 2 gradi e può fare fino a 250 misure al secondo. Per impostazione predefinita invia ogni misura via UART a 115200 baud in un pacchetto di 9 byte: due byte di intestazione 0x59, distanza (cm), intensità del segnale, temperatura interna e un checksum. Se l'intensità è sotto 100 o pari a 65535 (sovraesposizione), la misura è considerata inaffidabile. Si alimenta a 5 V ma il livello logico UART è 3,3 V, quindi si collega direttamente a un ESP32. Poiché il SoftwareSerial dell'Uno non è affidabile a 115200 baud, scegli una scheda con UART hardware come ESP32 o Mega; la logica per decodificare i pacchetti UART è spiegata nell'articolo comunicazione seriale UART.

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: prossimità e rilevamento linea

Il TCRT5000 non è un misuratore di distanza ma un sensore a riflessione: la luce del LED infrarosso rimbalza sulla superficie e il fototransistor accanto misura quanta ne torna. Funziona al meglio a circa 2,5 mm e oltre 1,5 cm il segnale cala in fretta. Poiché il bianco riflette molto e il nero pochissimo, a parità di distanza dà valori del tutto diversi a seconda del colore; per questo si usa per distinguere nero e bianco nei robot segui-linea, per contare i fori dei dischi encoder e per rilevare oggetti molto vicini. Il comparatore del modulo commuta l'uscita digitale quando si supera la soglia regolata con il trimmer. Dettagli nell'articolo sensore infrarosso TCRT5000.

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

Effetto della superficie e dell'ambiente

La portata di un sensore sulla carta cambia quando incontra la superficie da misurare. Gli ultrasuoni sono eccellenti su superfici dure che riflettono il suono, ma soffrono con i tessuti che lo assorbono; i sensori a luce sono sensibili a colore, lucentezza e sole. La tabella mostra quale sensore resta affidabile in quale situazione mentre progetti.

Riepilogo collegamenti: Uno, ESP32 e Pico

Misura a ultrasuoni con il Raspberry Pi Pico

In MicroPython la durata di un impulso si misura con machine.time_pulse_us(); fa lo stesso lavoro di pulseIn() su Arduino e in caso di timeout restituisce un valore negativo. Alimenta l'HC-SR04 dal pin VBUS (5 V dell'USB) del Pico e metti un partitore da 1 kΩ + 2 kΩ sulla linea ECHO, oppure usa l'HC-SR04P, che funziona direttamente a 3,3 V. Esistono driver MicroPython anche per VL53L0X e TF-Luna; il pacchetto UART del TF-Luna si decodifica facilmente con machine.UART seguendo la stessa logica del codice Arduino.

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

Quale sensore di distanza per quale progetto?

E qualche idea di progetto: fai ruotare un HC-SR04 su un servo per creare uno schermo radar con Arduino; usa un HC-SR04 davanti e due VL53L0X ai lati del tuo robot che evita gli ostacoli; apri il coperchio di un cestino intelligente quando si avvicina una mano; costruisci un metro digitale portatile con un display OLED, oppure invia al telefono il livello del serbatoio tramite un ESP32 con un JSN-SR04T.

Errori comuni e soluzioni

I sensori di distanza sono il modo più semplice per dare a un progetto Arduino la percezione dell'ambiente, e scegliere quello giusto fa la differenza tra un progetto che gira tranquillo e uno che fa impazzire. Le tabelle e i codici di questo confronto ti aiutano a bilanciare budget e prestazioni secondo le tue esigenze. Nell'app BlueGrays trovi progetti di misura della distanza con HC-SR04, sensore di parcheggio, misuratore di altezza, robot che evita gli ostacoli, sensore di parcheggio con ESP32 e misura della distanza con TCRT5000, passo passo con schema e codice.