Tipos de sensores de distância para Arduino: HC-SR04, IR, VL53L0X e LiDAR

Escolher entre os tipos de sensores de distância para Arduino parece, à primeira vista, uma questão de “qual mede mais longe”, mas o que realmente decide é a superfície que você vai medir, a exatidão necessária, o quanto o feixe precisa ser estreito e as condições do ambiente. O mesmo HC-SR04 que mede a distância até uma parede com exatidão de centímetros pode ficar instável diante do tecido macio de um sofá, enquanto um sensor laser barato que oferece precisão milimétrica pode perder metade do alcance sob a luz do sol. Neste guia, colocamos lado a lado os seis sensores mais usados em projetos com Arduino.

Os sensores que vamos comparar são: o ultrassônico HC-SR04 e seu irmão à prova d’água, o JSN-SR04T, o sensor de triangulação infravermelha Sharp GP2Y0A21, os sensores laser de tempo de voo (ToF) VL53L0X e VL53L1X, o pequeno LiDAR TF-Luna e o sensor de proximidade de curto alcance TCRT5000. Para cada um, explicamos o princípio de funcionamento, o alcance, a exatidão, o ângulo do feixe, a reação às superfícies e a interface, e fornecemos um sketch de exemplo compilado. No final, uma tabela resume qual escolher para cada projeto.

Como os sensores de distância medem? Três princípios básicos

Quase todos os sensores de distância usados com Arduino se baseiam em um de três métodos. Tempo de voo: o sensor emite um pulso de som ou luz e mede quanto tempo a reflexão leva para voltar; a distância é metade do produto entre tempo e velocidade. Sensores ultrassônicos fazem isso com som, e o VL53L0X e o TF-Luna, com luz. Como a luz é cerca de um milhão de vezes mais rápida que o som, sensores ToF contêm chips especiais com temporização na escala de picossegundos. Triangulação: sensores Sharp IR emitem um feixe infravermelho em direção ao alvo e verificam onde a luz refletida atinge um detector sensível à posição (PSD); para objetos próximos, o ponto se desloca para uma extremidade e, para os distantes, para a outra. Intensidade da reflexão: sensores simples como o TCRT5000 medem apenas a intensidade da luz que retorna; como isso depende muito da cor da superfície, trata-se de detecção de proximidade, e não de uma medição real de distância.

A tabela geral de comparação

A tabela abaixo reúne os valores típicos dos módulos de cada sensor. Os alcances são os informados pelos fabricantes; em um projeto real, podem ser menores dependendo da superfície e do ambiente. Os preços variam conforme o país, por isso são apresentados em termos relativos.

HC-SR04: o clássico ultrassônico

O HC-SR04 emite oito pulsos sonoros de 40 kHz e mantém o pino ECHO em HIGH até o eco retornar. O Arduino mede a duração desse pulso em microssegundos com pulseIn(). A 20 °C, o som percorre cerca de 343 metros por segundo, ou 0,0343 cm por microssegundo; como o som vai até o alvo e volta, distância = tempo × 0,0343 / 2. A velocidade do som varia com a temperatura (cerca de 331,3 + 0,606 × T m/s): entre 0 °C e 35 °C, há uma diferença de cerca de 6%, o que significa até 12 cm de erro a 2 metros. O código abaixo aplica essa correção e usa a mediana de cinco leituras para eliminar ecos incorretos ocasionais.

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

• Espere pelo menos 60 ms entre as leituras: se você medir novamente enquanto os ecos do pulso anterior ainda estiverem se refletindo pelo ambiente, os resultados serão incorretos.
• Superfícies macias e inclinadas: tecido, espuma e cortinas absorvem som; superfícies inclinadas mais de 45 graus refletem o eco para longe do sensor.
• Feixe amplo: o cone de aproximadamente 15 graus cobre uma área com quase 50 cm de largura a 2 metros; em um corredor estreito, ele também pode detectar as paredes laterais.
• Placas de 3,3 V: o HC-SR04 clássico precisa de 5 V e sua saída ECHO é de 5 V; no ESP32 e no Pico, coloque um divisor de tensão no ECHO ou use o HC-SR04P, que funciona com 3,3 V.
• Vários sensores: dois HC-SR04 acionados ao mesmo tempo captam os ecos um do outro; acione-os um após o outro.

A ligação do HC-SR04 e seu uso com o Monitor Serial e um LCD são explicados em detalhes no artigo sobre o sensor de distância HC-SR04; aqui, o foco é a comparação.

JSN-SR04T: o ultrassônico à prova d’água

O JSN-SR04T funciona com a mesma lógica de disparo e eco do HC-SR04, mas seu transdutor fica em uma cápsula à prova d’água ligada por um cabo, separada da placa eletrônica. Isso o torna a escolha para locais úmidos, como caixas-d’água, poços, cisternas de chuva e sensores de estacionamento externos. Ele tem duas diferenças importantes: como um único transdutor emite e escuta, há uma zona cega a curta distância (cerca de 20–25 cm), e seu feixe é mais amplo que o do HC-SR04. Instale o sensor na tampa superior do reservatório, pelo menos 25 cm acima do nível máximo da água. O código abaixo transforma a distância em um percentual de enchimento.

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

O Sharp GP2Y0A21YK0F é um sensor infravermelho que funciona entre 10 e 80 cm e fornece uma tensão analógica conforme a distância. Como usa triangulação, ele é menos sensível à cor do alvo que sensores baseados na intensidade da reflexão. Sua saída não é linear: fornece cerca de 2,3 V a 10 cm e 0,4 V a 80 cm, seguindo uma curva de potência inversa entre esses pontos. O código converte essa curva com a aproximação distância = 29.988 × V^-1.173. A maior armadilha ocorre abaixo de 10 cm: à medida que o alvo se aproxima, a saída volta a cair, e um objeto a 5 cm pode parecer estar a 20 cm. Instale o sensor de modo que o alvo nunca possa se aproximar 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

Sensores Sharp consomem pulsos curtos de alta corrente durante a medição, e esses pulsos geram ruído na linha de alimentação. Um capacitor de aproximadamente 10 µF próximo aos pinos VCC e GND do sensor estabiliza bastante as leituras. A família também tem modelos com outros alcances: o GP2Y0A41SK0F funciona de 4 a 30 cm, e o GP2Y0A02YK0F, de 20 a 150 cm; cada um tem coeficientes de curva diferentes.

VL53L0X e VL53L1X: sensores laser ToF

O VL53L0X e o VL53L1X são minúsculos sensores laser de tempo de voo da STMicroelectronics. Eles emitem um pulso laser invisível de 940 nm, medem o tempo de retorno da reflexão com contadores de fótons e fornecem o resultado diretamente em milímetros via I2C. São quase independentes da cor, seu feixe é mais estreito que o de um sensor ultrassônico e uma medição leva 20–50 ms. O VL53L0X mede até cerca de 1,2 metro no modo padrão e 2 metros no modo de longo alcance; o VL53L1X chega a 4 metros e seu campo de visão (ROI) pode ser reduzido por software. Ambos têm o endereço I2C padrão 0x29. O código abaixo usa a biblioteca VL53L0X da Pololu; busque “VL53L0X” no Gerenciador de Bibliotecas e instale a versão da 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

O tempo reservado para a medição define o equilíbrio entre exatidão e velocidade: 20 ms é rápido, mas gera ruído; 200 ms é lento, mas estável. A luz solar e fontes intensas de infravermelho reduzem bastante o alcance; lembre-se disso se for medir ao ar livre. Para conectar dois VL53L0X ao mesmo barramento I2C, como ambos têm o endereço 0x29, mantenha um desativado pelo pino XSHUT e atribua um novo endereço ao outro (setAddress); os detalhes do I2C estão no artigo O que é I2C.

TF-Luna: 8 metros com um pequeno LiDAR

O TF-Luna é o pequeno LiDAR de ponto único da Benewake: ele mede o tempo de voo modulando luz infravermelha de 850 nm, funciona de 0,2 a 8 metros com um feixe muito estreito de apenas 2 graus e pode fazer até 250 leituras por segundo. Por padrão, envia cada leitura via UART a 115200 baud como um pacote de 9 bytes: dois bytes de cabeçalho 0x59, distância (cm), intensidade do sinal, temperatura interna e uma soma de verificação. Se a intensidade do sinal for inferior a 100 ou igual a 65.535 (superexposição), a leitura é considerada pouco confiável. Ele é alimentado com 5 V, mas seu nível lógico UART é de 3,3 V, então pode ser conectado diretamente a um ESP32. Como a SoftwareSerial do Uno não é confiável a 115200 baud, escolha uma placa com UART por hardware, como o ESP32 ou o Mega; a lógica de interpretação de pacotes UART é explicada no artigo sobre comunicação serial 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: detecção de proximidade e de linha

O TCRT5000 não é um medidor de distância, mas um sensor reflexivo: a luz do LED infravermelho é refletida pela superfície, e o fototransistor ao lado mede quanto retorna. Ele funciona melhor a cerca de 2,5 mm, e o sinal enfraquece rapidamente além de 1,5 cm. Como superfícies brancas refletem muito e as pretas muito pouco, ele fornece valores completamente diferentes conforme a cor, mesmo à mesma distância; por isso, é usado para distinguir preto de branco em robôs seguidores de linha, contar furos em discos de encoder e detectar objetos muito próximos. O comparador do módulo comuta a saída digital quando o limiar ajustado pelo potenciômetro é ultrapassado. Veja os detalhes no artigo sobre o sensor infravermelho 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

Efeito da superfície e do ambiente

O alcance de um sensor no papel muda quando ele encontra a superfície que você vai medir. Sensores ultrassônicos são excelentes em superfícies rígidas que refletem som, mas têm dificuldade com tecidos que o absorvem; sensores baseados em luz são afetados pela cor, pelo brilho e pela luz solar. A tabela abaixo mostra qual sensor permanece confiável em cada situação para ajudar você a planejar seu projeto.

Resumo das ligações: Uno, ESP32 e Pico

Medição ultrassônica com o Raspberry Pi Pico

No MicroPython, a duração do pulso é medida com machine.time_pulse_us(); ela faz o mesmo que pulseIn() no Arduino e retorna um valor negativo quando o tempo limite é excedido. Alimente o HC-SR04 pelo pino VBUS (USB 5 V) do Pico e coloque um divisor de 1 kΩ + 2 kΩ na linha ECHO, ou use o HC-SR04P, que funciona diretamente com 3,3 V. Também existem drivers MicroPython para o VL53L0X e o TF-Luna; você pode interpretar facilmente o pacote UART do TF-Luna com machine.UART usando a mesma lógica do código 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

Qual sensor de distância usar em cada projeto?

Mais algumas ideias de projetos: gire um HC-SR04 com um servo para montar uma visualização de radar com Arduino; use um HC-SR04 na frente e dois VL53L0X nas laterais do seu robô que desvia de obstáculos; abra a tampa de uma lixeira inteligente quando uma mão se aproximar; monte uma trena digital portátil com um display OLED ou envie o nível de enchimento da caixa-d’água para seu celular por meio de um ESP32 com um JSN-SR04T.

Erros comuns e soluções

Sensores de distância são a maneira mais fácil de fazer projetos com Arduino perceberem o ambiente ao redor, e escolher o modelo certo é o que diferencia um projeto estável de outro que tira você do sério. As tabelas e o código desta comparação ajudam a equilibrar orçamento e desempenho conforme suas necessidades. No app BlueGrays, você encontra projetos passo a passo com esquemas do circuito e código para medição de distância com HC-SR04, sensor de estacionamento, medidor de altura, robô que desvia de obstáculos, sensor de estacionamento com ESP32 e medição de distância com TCRT5000.