Sensores de distancia Arduino: HC-SR04, IR, VL53L0X y LiDAR

Elegir entre los sensores de distancia para Arduino parece al principio una cuestión de «cuál mide más lejos», pero lo que de verdad decide es la superficie que vas a medir, la precisión que necesitas, lo estrecho que debe ser el haz y las condiciones del entorno. El mismo HC-SR04 que mide la distancia a una pared con precisión de centímetro puede volverse inestable con la tela blanda de un sofá, y un sensor láser barato que da precisión milimétrica puede perder la mitad de su alcance al sol. En esta guía ponemos lado a lado los seis sensores más usados en proyectos Arduino.

Los sensores que comparamos son: el ultrasónico HC-SR04 y su hermano impermeable JSN-SR04T, el sensor infrarrojo de triangulación Sharp GP2Y0A21, los sensores láser de tiempo de vuelo (ToF) VL53L0X y VL53L1X, el pequeño LiDAR TF-Luna y el sensor de proximidad de corto alcance TCRT5000. De cada uno explicamos el principio de funcionamiento, el alcance, la precisión, el ángulo del haz, su reacción ante las superficies y la interfaz, y damos un código de ejemplo compilado. Al final, una tabla resume cuál elegir para cada proyecto.

¿Cómo miden los sensores de distancia? Tres principios básicos

Casi todos los sensores de distancia que se usan con Arduino se basan en uno de tres métodos. Tiempo de vuelo: el sensor envía un pulso de sonido o de luz y mide cuánto tarda en volver el reflejo; la distancia es la mitad del producto del tiempo por la velocidad. Los ultrasónicos lo hacen con sonido, el VL53L0X y el TF-Luna con luz. Como la luz es aproximadamente un millón de veces más rápida que el sonido, los sensores ToF llevan chips especiales que temporizan a nivel de picosegundos. Triangulación: los sensores Sharp IR envían un haz infrarrojo al objetivo y miran dónde cae la luz reflejada sobre un detector sensible a la posición (PSD); con objetos cercanos el punto se desplaza a un extremo y con lejanos al otro. Intensidad de reflexión: sensores sencillos como el TCRT5000 solo miden lo fuerte que vuelve la luz; como eso depende mucho del color de la superficie, es detección de proximidad más que medida real de distancia.

La gran tabla comparativa

La tabla siguiente reúne los valores típicos de los módulos. Los alcances son los que dan los fabricantes; en un proyecto real pueden ser menores según la superficie y el entorno. Como los precios cambian según el país, se indican de forma relativa.

HC-SR04: el clásico ultrasónico

El HC-SR04 emite ocho pulsos de sonido de 40 kHz y mantiene su pin ECHO en HIGH hasta que vuelve el eco. El Arduino mide la duración de ese pulso en microsegundos con pulseIn(). A 20 °C el sonido recorre unos 343 metros por segundo, es decir, 0,0343 cm por microsegundo; como el sonido va al objetivo y vuelve, distancia = tiempo × 0,0343 / 2. La velocidad del sonido cambia con la temperatura (aproximadamente 331,3 + 0,606 × T m/s): entre 0 °C y 35 °C hay alrededor de un 6 % de diferencia, lo que supone hasta 12 cm de error a 2 metros. El código de abajo aplica esa corrección y toma la mediana de cinco medidas para descartar algún eco erróneo ocasional.

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

• Espera al menos 60 ms entre medidas: si mides de nuevo mientras los ecos del pulso anterior siguen rebotando por la habitación, obtendrás resultados erróneos.
• Superficies blandas e inclinadas: la tela, la espuma y las cortinas absorben el sonido; las superficies inclinadas más de 45 grados desvían el eco lejos del sensor.
• Haz ancho: el cono de unos 15 grados cubre a 2 metros una zona de casi 50 cm de diámetro; en un pasillo estrecho puede ver también las paredes laterales.
• Placas de 3,3 V: el HC-SR04 clásico necesita 5 V y su salida ECHO es de 5 V; en el ESP32 y la Pico pon un divisor de tensión en ECHO o usa el HC-SR04P, que funciona a 3,3 V.
• Varios sensores: dos HC-SR04 disparados a la vez oyen el eco del otro; dispáralos uno tras otro.

La conexión del HC-SR04 y su uso con el Monitor Serie y una pantalla LCD se explican en detalle en el artículo sensor de distancia HC-SR04; aquí nos centramos en la comparación.

JSN-SR04T: el ultrasónico impermeable

El JSN-SR04T funciona con la misma lógica de disparo y eco que el HC-SR04, pero su transductor va en una cápsula impermeable al final de un cable, separado de la placa electrónica. Por eso es el elegido para lugares húmedos como depósitos de agua, pozos, aljibes de lluvia y sensores de aparcamiento exteriores. Tiene dos diferencias importantes: como un solo transductor emite y escucha, hay una zona ciega a corta distancia (unos 20–25 cm), y su haz es más ancho que el del HC-SR04. Monta el sensor en la tapa superior del depósito, al menos 25 cm por encima del nivel máximo de agua. El código de abajo convierte la distancia en porcentaje de llenado.

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: infrarrojo analógico

El Sharp GP2Y0A21YK0F es un sensor infrarrojo que trabaja entre 10 y 80 cm y entrega una tensión analógica según la distancia. Como usa triangulación, es menos sensible al color del objetivo que los sensores basados en la intensidad de reflexión. Su salida no es lineal: da unos 2,3 V a 10 cm y 0,4 V a 80 cm, y sigue una curva potencial inversa entre ambos. El código convierte esa curva con la aproximación distancia = 29,988 × V^-1,173. La trampa más importante está por debajo de 10 cm: cuando el objetivo se acerca, la salida vuelve a bajar y un objeto a 5 cm puede parecer que está a 20 cm. Monta el sensor de forma que el objetivo nunca pueda acercarse a menos de 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

Los sensores Sharp consumen pulsos de corriente cortos y altos al medir, y esos pulsos generan ruido en la alimentación. Un condensador de unos 10 µF cerca de los pines VCC y GND del sensor tranquiliza mucho las lecturas. La familia tiene miembros con otros rangos: el GP2Y0A41SK0F trabaja de 4 a 30 cm y el GP2Y0A02YK0F de 20 a 150 cm; cada uno tiene coeficientes de curva distintos.

VL53L0X y VL53L1X: sensores láser ToF

El VL53L0X y el VL53L1X son diminutos sensores láser de tiempo de vuelo de STMicroelectronics. Envían un pulso láser invisible de 940 nm, miden con contadores de fotones el tiempo de retorno del reflejo y entregan el resultado directamente en milímetros por I2C. Son casi independientes del color, su haz es más estrecho que el de un ultrasónico y cada medida tarda 20–50 ms. El VL53L0X mide hasta 1,2 metros aproximadamente en modo normal y hasta 2 metros en modo de largo alcance; el VL53L1X llega a 4 metros y su campo de visión (ROI) se puede estrechar por software. Ambos tienen la dirección I2C por defecto 0x29. El código usa la librería VL53L0X de Pololu; busca «VL53L0X» en el Gestor de Librerías e instala la versión de 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

El presupuesto de tiempo de medida (timing budget) fija el equilibrio entre precisión y velocidad: 20 ms es rápido pero ruidoso, 200 ms lento pero estable. La luz solar y las fuentes infrarrojas fuertes acortan claramente el alcance; tenlo en cuenta si vas a medir al aire libre. Para conectar dos VL53L0X al mismo bus I2C, como ambos tienen la dirección 0x29, mantienes uno apagado con su pin XSHUT y le das al otro una dirección nueva (setAddress); los detalles de I2C están en el artículo Qué es I2C.

TF-Luna: 8 metros con un pequeño LiDAR

El TF-Luna es el pequeño LiDAR de un solo punto de Benewake: mide el tiempo de vuelo modulando luz infrarroja de 850 nm, trabaja de 0,2 a 8 metros con un haz muy estrecho de solo 2 grados y puede hacer hasta 250 medidas por segundo. Por defecto envía cada medida por UART a 115200 baudios en un paquete de 9 bytes: dos bytes de cabecera 0x59, distancia (cm), intensidad de señal, temperatura interna y una suma de control. Si la intensidad es menor de 100 o igual a 65535 (sobreexposición), la medida se considera poco fiable. Se alimenta a 5 V pero su nivel lógico UART es de 3,3 V, así que se conecta directamente a un ESP32. Como el SoftwareSerial del Uno no es fiable a 115200 baudios, elige una placa con UART por hardware como el ESP32 o la Mega; la lógica para interpretar paquetes UART se explica en el artículo comunicación serie 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: proximidad y detección de líneas

El TCRT5000 no mide distancias, es un sensor de reflexión: la luz del LED infrarrojo rebota en la superficie y el fototransistor que tiene al lado mide cuánta vuelve. Funciona mejor a unos 2,5 mm y la señal se debilita rápido a partir de 1,5 cm. Como el blanco refleja mucho y el negro muy poco, da valores totalmente distintos según el color incluso a la misma distancia; por eso se usa para distinguir negro y blanco en robots siguelíneas, contar agujeros en discos de encoder y detectar objetos muy cercanos. El comparador del módulo cambia la salida digital cuando se supera el umbral ajustado con el potenciómetro. Detalles en el artículo sensor infrarrojo 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

Efecto de la superficie y del entorno

El alcance de un sensor sobre el papel cambia cuando se encuentra con la superficie que vas a medir. Los ultrasónicos son excelentes con superficies duras que reflejan el sonido, pero sufren con telas que lo absorben; los sensores de luz se fijan en el color, el brillo y el sol. La tabla muestra qué sensor sigue siendo fiable en cada situación al diseñar tu proyecto.

Resumen de conexiones: Uno, ESP32 y Pico

Medida ultrasónica con la Raspberry Pi Pico

En MicroPython la duración del pulso se mide con machine.time_pulse_us(); hace lo mismo que pulseIn() en Arduino y devuelve un valor negativo si se agota el tiempo. Alimenta el HC-SR04 desde el pin VBUS (5 V del USB) de la Pico y pon un divisor de 1 kΩ + 2 kΩ en la línea ECHO, o usa el HC-SR04P, que funciona directamente a 3,3 V. También hay drivers de MicroPython para el VL53L0X y el TF-Luna; el paquete UART del TF-Luna se interpreta fácilmente con machine.UART siguiendo la misma lógica que el código de 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

¿Qué sensor de distancia para cada proyecto?

Y algunas ideas de proyectos: gira un HC-SR04 sobre un servo para crear una pantalla de radar con Arduino; usa un HC-SR04 delante y dos VL53L0X a los lados en tu robot que esquiva obstáculos; abre la tapa de una papelera inteligente cuando se acerque una mano; monta un metro digital portátil con una pantalla OLED, o envía al móvil el nivel de tu depósito de agua a través de un ESP32 con un JSN-SR04T.

Errores frecuentes y soluciones

Los sensores de distancia son la forma más sencilla de dar a un proyecto Arduino conciencia de su entorno, y elegir el adecuado marca la diferencia entre un proyecto que funciona con estabilidad y otro que desespera. Las tablas y los códigos de esta comparativa te ayudan a equilibrar presupuesto y rendimiento según tus necesidades. En la app BlueGrays encontrarás proyectos de medición de distancia con HC-SR04, sensor de aparcamiento, medidor de altura, robot que esquiva obstáculos, sensor de aparcamiento con ESP32 y medición de distancia con TCRT5000, paso a paso con esquema y código.