VL53L0X com Arduino: sensor de distância a laser com alcance de 2 m
Como usar o sensor de distância a laser VL53L0X com Arduino, ESP32 e Pico? Ligação I2C, perfis de medição, vários sensores com XSHUT e comparação com o HC-SR04.
O VL53L0X é um sensor de distância a laser ToF (Time of Flight, tempo de voo), uma das formas mais compactas e precisas de medir distância com Arduino. Fabricado pela STMicroelectronics, o chip emite um pulso de laser invisível de 940 nm, mede quanto tempo a luz leva para bater no alvo e voltar e entrega o resultado direto em milímetros. O módulo, do tamanho de um selo, é ligado só pelos dois fios de dados do I2C; ele mede até cerca de 1,2 metro no modo padrão e até 2 metros no modo de longo alcance.
Neste guia você vai aprender passo a passo como o VL53L0X funciona, como ligá-lo ao Arduino Uno, ao ESP32 e ao Raspberry Pi Pico, a diferença entre os quatro perfis de medição e como colocar vários sensores no mesmo barramento I2C usando o pino XSHUT. Você também vai compará-lo com o popular sensor de distância HC-SR04, que é ultrassônico, e ver qual faz mais sentido em cada projeto.
O que é o VL53L0X e como ele funciona?
Dentro do sensor há duas partes principais: um VCSEL (laser de emissão superficial com cavidade vertical), que emite a luz, e uma matriz de SPADs (diodos de avalanche de fóton único), capazes de detectar até um único fóton. O VCSEL envia pulsos de luz muito curtos, a matriz de SPADs capta os fótons que voltam e o chip mede o tempo entre os dois. A distância vem de uma fórmula simples: d = c × t / 2. Aqui c é a velocidade da luz (cerca de 300.000 km/s) e, como a luz percorre o caminho duas vezes, o resultado é dividido por dois. Para um objeto a 1 metro, a ida e volta leva só 6,67 nanossegundos. Medir um tempo tão curto com um único pulso é quase impossível, então o chip reúne a estatística de milhares de pulsos e faz o cálculo internamente; você só lê o resultado pronto.
O laser é de Classe 1, então não é perigoso para os olhos no uso normal e, por ser infravermelho, não dá para vê-lo. O campo de visão do sensor é de cerca de 25 graus, ou seja, a medição acontece dentro de um cone estreito. Isso permite mirar muito melhor do que com a onda sonora larga do HC-SR04; você consegue medir um objeto pequeno na beirada de uma mesa sem pegar a parede ao lado. Como o resultado depende da velocidade da luz, ele quase não é afetado pela temperatura ou pela umidade do ar.
| Característica | Valor |
|---|---|
| Chip | STMicroelectronics VL53L0X |
| Princípio de medição | Tempo de voo (ToF), laser VCSEL de 940 nm, Classe 1 |
| Alcance | Cerca de 3 cm – 1,2 m (padrão), até 2 m (modo de longo alcance, ambiente escuro, alvo branco) |
| Resolução | 1 mm |
| Precisão | Cerca de ±3% – ±5%, conforme o modo |
| Campo de visão | Cerca de 25° |
| Tempo de medição | 20 ms – 200 ms (conforme o orçamento de tempo) |
| Alimentação | Chip 2,6–3,5 V; a maioria dos módulos tem regulador, 3,3–5 V |
| Corrente | Cerca de 19 mA durante a medição, alguns µA em espera |
| Interface | I2C, até 400 kHz, endereço padrão 0x29 |
| Pinos | VIN, GND, SCL, SDA, GPIO1 (interrupção), XSHUT (desligamento) |
VL53L0X ou HC-SR04?
Os dois sensores medem distância, mas a física deles é completamente diferente. O HC-SR04 envia uma onda sonora de 40 kHz e escuta o eco; o som viaja a cerca de 343 m/s, então a medição do tempo é fácil e o alcance chega a 4 metros. Porém, o cone sonoro largo também pega objetos dos lados, e tecido, espuma e superfícies inclinadas absorvem ou desviam o som. O VL53L0X mede com luz: é minúsculo, mira o alvo com um ângulo estreito, é mais estável em distâncias curtas e, graças ao I2C, vários sensores podem compartilhar um único barramento. Por outro lado, luz solar direta, superfícies muito escuras ou brilhantes como espelho e vidro atrapalham. Resumindo: se você precisa de uma medição pequena e rápida abaixo de 2 metros, escolha o VL53L0X; se precisa de mais alcance e uso ao ar livre, o HC-SR04 faz mais sentido. Para outras opções, veja a comparação de sensores de distância.
| Característica | VL53L0X | HC-SR04 |
|---|---|---|
| Princípio de medição | Tempo de voo da luz laser (940 nm) | Eco de som ultrassônico (40 kHz) |
| Alcance | Cerca de 3 cm – 2 m | Cerca de 2 cm – 4 m |
| Cone de medição | Cerca de 25°, estreito e bem definido | Ângulo de medição de cerca de 15°, o som se espalha mais |
| Resolução | 1 mm | Cerca de 3 mm (±1 cm na prática) |
| Ligação | I2C (SDA, SCL) | 2 pinos digitais (Trig, Echo) |
| Vários sensores | No mesmo barramento I2C com XSHUT | Um pino separado para cada sensor, um pode ouvir o eco do outro |
| Alimentação | 3,3–5 V (módulo) | 5 V |
| Tamanho | Cerca de 25 × 13 mm | Cerca de 45 × 20 mm |
| Tem dificuldade com | Superfícies pretas ou espelhadas, vidro, luz solar | Tecido, espuma, superfícies inclinadas, ambientes barulhentos |
Ligação do VL53L0X: Arduino Uno, ESP32 e Pico
A maioria dos módulos à venda (como o GY-530 e o GY-VL53L0XV2) traz um regulador de 2,8 V, resistores de pull-up para as linhas I2C e um resistor de pull-up para o XSHUT. Isso significa que você pode ligar o módulo ao pino 5V do Uno ou ao pino 3V3 do ESP32 e do Pico. A maioria dos módulos baratos se comunica com o Uno sem problemas; mesmo assim, em projetos que vão funcionar por muito tempo, você pode usar um conversor de nível lógico para proteger as linhas I2C. Se tiver curiosidade sobre como o barramento I2C funciona, leia O que é I2C. O GPIO1 é uma saída de interrupção que avisa quando a medição termina; no uso básico, não é preciso ligá-lo.
| Pino do VL53L0X | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN | 5V (ou 3.3V) | 3V3 | 3V3(OUT) |
| GND | GND | GND | GND |
| SCL | A5 | GPIO 22 | GP5 |
| SDA | A4 | GPIO 21 | GP4 |
| XSHUT (opcional) | D4 (D5 no 2º sensor) | GPIO 25 | GP6 |
| GPIO1 (opcional) | Não ligado | Não ligado | Não ligado |
Passo a passo: sua primeira medição com Arduino
- Faça a ligação de acordo com a tabela: VIN → 5V, GND → GND, SDA → A4, SCL → A5.
- Se houver uma fita protetora amarela ou laranja sobre o sensor, retire-a com cuidado; a fita estraga a medição por completo.
- No Arduino IDE, abra o Gerenciador de Bibliotecas, digite VL53L0X e instale a biblioteca da Pololu. A Adafruit_VL53L0X também funciona, mas inclui a API completa da ST e ocupa muito mais memória no Uno. Se travar na instalação, veja como instalar bibliotecas no Arduino.
- Carregue o código abaixo e abra o Monitor Serial a 115200 baud.
- Aproxime e afaste a mão do sensor e veja os valores mudarem em milímetros e centímetros.
1#include <Wire.h>
2#include <VL53L0X.h>
3
4VL53L0X sensor;
5
6void setup() {
7 Serial.begin(115200);
8 Wire.begin(); // Uno: SDA=A4, SCL=A5
9 sensor.setTimeout(500); // 500 ms cevap bekle / wait 500 ms for a reply
10 if (!sensor.init()) {
11 Serial.println(F("VL53L0X bulunamadi / not found"));
12 while (1) {}
13 }
14 sensor.startContinuous(); // sürekli ölçüm / continuous ranging
15}
16
17void loop() {
18 uint16_t mm = sensor.readRangeContinuousMillimeters();
19 if (sensor.timeoutOccurred()) {
20 Serial.println(F("Zaman asimi / Timeout"));
21 return;
22 }
23 if (mm > 2000) { // geçerli yansıma yok / no valid return
24 Serial.println(F("Menzil disi / Out of range"));
25 } else {
26 Serial.print(mm);
27 Serial.print(F(" mm = "));
28 Serial.print(mm / 10.0, 1);
29 Serial.println(F(" cm"));
30 }
31 delay(100);
32}| Comando | O que faz |
|---|---|
| sensor.setTimeout(500) | Para de esperar se o sensor não responder em 500 ms, assim o código não trava para sempre. |
| sensor.init() | Carrega a sequência de configuração da ST e faz a calibração dos SPADs; se retornar false, o sensor não foi encontrado no barramento I2C. |
| sensor.startContinuous() | Faz o sensor medir uma vez atrás da outra, sem pausa. |
| sensor.readRangeContinuousMillimeters() | Retorna a medição mais recente em milímetros; sem alvo, vem um valor por volta de 8190. |
| sensor.timeoutOccurred() | Retorna true se a última leitura excedeu o tempo limite (nesse caso o valor é 65535). |
Modos de medição do VL53L0X
Três ajustes determinam a qualidade da medição no VL53L0X: o orçamento de tempo (timing budget, o tempo dado a uma medição), o limite da taxa de sinal (o retorno mais fraco que ainda conta como válido) e o período do pulso do VCSEL (a duração dos pulsos de laser). Quanto maior o orçamento, mais fótons o sensor coleta e mais estável fica a leitura, mas ela fica mais lenta; um orçamento de 200 ms significa só 5 medições por segundo. Baixar o limite de sinal do padrão de 0,25 MCPS para 0,1 MCPS faz o sensor aceitar retornos mais fracos e aumenta o alcance, mas eleva o risco de leituras erradas. Aumentar os períodos de pulso do padrão de 14 e 10 para 18 e 14 envia mais energia para alvos distantes. A ST define esses ajustes como quatro perfis prontos; no código abaixo, você escolhe o que quiser removendo o marcador de comentário no início da linha. Também dá para combinar o ajuste de longo alcance com um ajuste de velocidade ou de precisão.
| Perfil | Orçamento de tempo | Alcance típico | Precisão | Quando usar |
|---|---|---|---|---|
| Padrão | Cerca de 30 ms | 1,2 m | Cerca de ±3–4% | Medição de uso geral |
| Alta precisão | 200 ms | 1,2 m | Abaixo de ±3% | Medição de nível, régua de precisão |
| Longo alcance | 33 ms | 2 m | Cerca de ±4% | Ambiente escuro, alvo distante |
| Alta velocidade | 20 ms | 1,2 m | Cerca de ±5% | Robô rápido, detecção de gestos da mão |
1#include <Wire.h>
2#include <VL53L0X.h>
3
4VL53L0X sensor;
5
6// Profil seç: istediğin satırın yorumunu kaldır / Pick a profile: uncomment the line you want
7#define UZUN_MENZIL // uzun menzil / long range
8//#define YUKSEK_HIZ // yüksek hız / high speed
9//#define YUKSEK_DOGRULUK // yüksek doğruluk / high accuracy
10
11void setup() {
12 Serial.begin(115200);
13 Wire.begin();
14 sensor.setTimeout(500);
15 if (!sensor.init()) {
16 Serial.println(F("Sensor yok / No sensor"));
17 while (1) {}
18 }
19
20#if defined UZUN_MENZIL
21 sensor.setSignalRateLimit(0.1); // varsayılan 0.25 MCPS / default 0.25 MCPS
22 sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18); // varsayılan 14 / default 14
23 sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14); // varsayılan 10 / default 10
24#endif
25
26#if defined YUKSEK_HIZ
27 sensor.setMeasurementTimingBudget(20000); // 20 ms
28#elif defined YUKSEK_DOGRULUK
29 sensor.setMeasurementTimingBudget(200000); // 200 ms
30#endif
31}
32
33void loop() {
34 Serial.print(sensor.readRangeSingleMillimeters()); // tek seferlik ölçüm / single-shot ranging
35 if (sensor.timeoutOccurred()) {
36 Serial.print(F(" ZAMAN ASIMI / TIMEOUT"));
37 }
38 Serial.println();
39}Vários sensores VL53L0X: mudando o endereço com XSHUT
Todo VL53L0X sai de fábrica com o mesmo endereço 0x29, e esse endereço não pode ser mudado de forma permanente. Se você ligar dois sensores diretamente no mesmo barramento, os dois respondem ao mesmo tempo e a comunicação falha. A solução é o pino XSHUT: enquanto o XSHUT está em LOW, o sensor fica completamente desligado e invisível no barramento I2C. Na inicialização, você acorda os sensores um a um e dá a cada um novo endereço por software. O novo endereço só vale até a alimentação ser cortada ou o XSHUT voltar a LOW, por isso isso é feito no setup() a cada inicialização. Com esse método, é fácil equipar um robô com três sensores, à esquerda, no centro e à direita; na prática, o limite é a quantidade de pinos digitais livres e o comprimento total dos fios.
- Ligue os pinos VIN, GND, SDA e SCL de todos os sensores ao barramento comum; ligue o pino XSHUT de cada sensor a um pino digital separado (D4 e D5 no exemplo).
- No início do setup(), coloque todos os pinos XSHUT em LOW para desligar todos os sensores.
- Acorde o sensor 1, inicie-o com init() e dê o novo endereço com setAddress(0x30).
- Acorde o sensor 2, inicie-o e dê o endereço 0x31; se houver mais sensores, continue com 0x32, 0x33 e assim por diante.
- Inicie a medição contínua em todos os sensores e leia cada um pelo seu próprio objeto.
1#include <Wire.h>
2#include <VL53L0X.h>
3
4const uint8_t XSHUT_1 = 4;
5const uint8_t XSHUT_2 = 5;
6
7VL53L0X sensor1;
8VL53L0X sensor2;
9
10void setup() {
11 Serial.begin(115200);
12 Wire.begin();
13
14 pinMode(XSHUT_1, OUTPUT);
15 pinMode(XSHUT_2, OUTPUT);
16 digitalWrite(XSHUT_1, LOW); // iki sensörü de kapat / shut down both sensors
17 digitalWrite(XSHUT_2, LOW);
18 delay(10);
19
20 pinMode(XSHUT_1, INPUT); // 1. sensörü aç, modülün pull-up direnci HIGH yapar / wake sensor 1, module pull-up pulls it HIGH
21 delay(10);
22 sensor1.setTimeout(500);
23 if (!sensor1.init()) {
24 Serial.println(F("Sensor 1 yok / Sensor 1 missing"));
25 while (1) {}
26 }
27 sensor1.setAddress(0x30); // yeni adres / new address
28
29 pinMode(XSHUT_2, INPUT); // 2. sensörü aç / wake sensor 2
30 delay(10);
31 sensor2.setTimeout(500);
32 if (!sensor2.init()) {
33 Serial.println(F("Sensor 2 yok / Sensor 2 missing"));
34 while (1) {}
35 }
36 sensor2.setAddress(0x31);
37
38 sensor1.startContinuous();
39 sensor2.startContinuous();
40}
41
42void loop() {
43 Serial.print(F("Sol / Left: "));
44 Serial.print(sensor1.readRangeContinuousMillimeters());
45 Serial.print(F(" mm Sag / Right: "));
46 Serial.print(sensor2.readRangeContinuousMillimeters());
47 Serial.println(F(" mm"));
48 delay(100);
49}VL53L0X com o ESP32
No ESP32, a mesma biblioteca da Pololu funciona sem alterações. Os pinos I2C padrão são o GPIO 21 (SDA) e o GPIO 22 (SCL); indicá-los explicitamente com Wire.begin(21, 22) evita surpresas em placas diferentes. Como os pinos do ESP32 são de 3,3 V, você pode colocar o XSHUT em HIGH diretamente; não precisa do método com INPUT usado no Uno. O exemplo abaixo mede com um orçamento de 50 ms, tira a média das últimas 5 leituras e acende o LED integrado da placa quando um objeto chega a menos de 15 cm. Tirar a média é a forma mais simples de suavizar valores que oscilam; para métodos mais avançados, veja filtragem de dados de sensores. Se quiser acompanhar a distância pelo celular, dá para combinar o código com o exemplo de servidor web com ESP32.
1#include <Wire.h>
2#include <VL53L0X.h>
3
4const int SDA_PIN = 21;
5const int SCL_PIN = 22;
6const int LED_PIN = 2; // çoğu DevKit'te dahili LED / onboard LED on most DevKits
7const uint16_t ESIK_MM = 150; // uyarı eşiği / warning threshold
8const uint8_t N = 5; // ortalama için örnek sayısı / samples for averaging
9
10VL53L0X sensor;
11uint16_t olcumler[N];
12uint8_t sira = 0;
13
14uint16_t olc() {
15 uint16_t mm = sensor.readRangeContinuousMillimeters();
16 if (mm > 2000) mm = 2000; // menzil dışını sınırla / clamp out-of-range values
17 return mm;
18}
19
20void setup() {
21 Serial.begin(115200);
22 pinMode(LED_PIN, OUTPUT);
23 Wire.begin(SDA_PIN, SCL_PIN);
24 Wire.setClock(400000); // hızlı I2C / fast-mode I2C
25 sensor.setTimeout(500);
26 if (!sensor.init()) {
27 Serial.println("VL53L0X bulunamadi / not found");
28 while (true) delay(1000);
29 }
30 sensor.setMeasurementTimingBudget(50000); // 50 ms bütçe / 50 ms budget
31 sensor.startContinuous();
32 for (uint8_t i = 0; i < N; i++) olcumler[i] = olc(); // diziyi doldur / pre-fill the buffer
33}
34
35void loop() {
36 uint16_t mm = olc();
37 if (sensor.timeoutOccurred()) {
38 Serial.println("Zaman asimi / Timeout");
39 return;
40 }
41 olcumler[sira] = mm;
42 sira = (sira + 1) % N;
43
44 uint32_t toplam = 0;
45 for (uint8_t i = 0; i < N; i++) toplam += olcumler[i];
46 uint16_t ortalama = toplam / N;
47
48 digitalWrite(LED_PIN, ortalama < ESIK_MM ? HIGH : LOW);
49 Serial.printf("Ham / Raw: %u mm Ortalama / Average: %u mm\n", (unsigned)mm, (unsigned)ortalama);
50 delay(50);
51}Raspberry Pi Pico e VL53L0X com MicroPython
O MicroPython não tem um módulo nativo para o VL53L0X; você precisa copiar para o Pico, com o Thonny, o arquivo de driver vl53l0x.py feito pela comunidade. Esses drivers levam a sequência de inicialização da ST para o Python e normalmente oferecem as funções start(), read() e stop(); confira uma vez os nomes das funções no arquivo do driver que você usar. Na ligação usamos o I2C0 nos pinos GP4 (SDA) e GP5 (SCL); uma varredura deve mostrar 0x29 (41 em decimal). A expressão Pin("LED") usada no código seleciona o LED integrado tanto no Pico quanto no Pico W a partir do MicroPython 1.20. A mesma lógica do XSHUT vale para vários sensores no Pico; como o Pico trabalha com 3,3 V, você pode colocar os pinos XSHUT em HIGH diretamente. Se você é novo no MicroPython, dê uma olhada antes em fundamentos do MicroPython.
1from machine import Pin, I2C
2import time
3from vl53l0x import VL53L0X # vl53l0x.py Pico'da olmalı / must be on the Pico
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
6print("I2C:", [hex(a) for a in i2c.scan()]) # 0x29 görmelisin / you should see 0x29
7
8tof = VL53L0X(i2c) # varsayılan adres 0x29 / default address 0x29
9led = Pin("LED", Pin.OUT) # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
10ESIK_MM = 150 # uyarı eşiği / warning threshold
11
12tof.start() # sürekli ölçüm / continuous ranging
13try:
14 while True:
15 mm = tof.read()
16 if mm > 2000:
17 print("Menzil disi / Out of range")
18 else:
19 print(mm, "mm")
20 led.value(1 if mm < ESIK_MM else 0)
21 time.sleep_ms(100)
22finally:
23 tof.stop() # ölçümü durdur / stop rangingDicas para medições precisas
- A cor do alvo importa: superfícies brancas e foscas refletem bem a luz; em superfícies pretas, cinza-escuras ou aveludadas, o alcance pode cair para a metade ou menos.
- Evite a luz do sol: a luz solar tem um forte componente infravermelho e aumenta o ruído de fundo do sensor. Ao ar livre, mantenha o sensor na sombra ou escolha o HC-SR04.
- Cuidado com o vidro de cobertura: se você colocar o sensor dentro de uma caixa, o vidro ou acrílico à frente reflete parte da luz de volta (crosstalk) e faz a leitura parecer mais curta. Se precisar de uma cobertura, escolha um material fino, transparente ao infravermelho e o mais próximo possível do sensor.
- Superfícies brilhantes como espelho: a luz pode ricochetear em outra direção numa superfície brilhante inclinada; mantenha o sensor o mais perpendicular possível à superfície.
- Alvos pequenos: o cone de 25 graus se alarga com a distância; a 1 metro, ele enxerga uma área de cerca de 44 cm de diâmetro. Ao medir um objeto pequeno de longe, a parede atrás dele também pode interferir no resultado.
- Mantenha os fios curtos: o barramento I2C se degrada com fios longos; em ligações com mais de 30 cm, baixe a velocidade para 100 kHz e passe os fios longe dos cabos dos motores.
Ideias de projetos com o VL53L0X
- Assistente de estacionamento na garagem: meça a distância do carro até a parede e mude a cor do LED conforme ele se aproxima. Para um exemplo detalhado, veja o post sistema de estacionamento com Arduino.
- Lixeira ou saboneteira sem toque: faça um servo abrir a tampa quando a mão chegar a 10 cm; no projeto da lixeira inteligente, você pode usar o VL53L0X no lugar do HC-SR04.
- Robô que desvia de obstáculos com três olhos: monte um sensor à esquerda, um no centro e um à direita e coloque todos no mesmo barramento com XSHUT; o robô que desvia de obstáculos faz curvas bem mais inteligentes.
- Indicador de nível de ração ou grãos: monte o sensor na tampa do reservatório e mostre a quantidade restante em porcentagem; combina muito bem com o projeto de alimentador automático para pets.
- Dimmer por gesto da mão: transforme a distância da mão até o sensor em brilho do LED com PWM; por exemplo, 5 cm é brilho máximo e 30 cm é apagado.
- Régua digital: mostre a distância medida em dígitos grandes num display OLED de 0,96 polegada e transforme o projeto num instrumento de medição de mesa.
Erros comuns e como resolvê-los
| Sintoma | Causa provável | Solução |
|---|---|---|
| init() retorna false, sensor não encontrado | SDA e SCL invertidos, sem alimentação ou pino errado | Procure o endereço 0x29 com um scanner I2C; confira se no Uno SDA = A4 e SCL = A5 |
| Valores parados por volta de 8190 | Alvo fora do alcance, fita protetora não retirada ou superfície escura demais | Retire a fita, aproxime o alvo, teste o perfil de longo alcance |
| Medição deslocada alguns centímetros | Offset do módulo ou vidro de cobertura na frente | Meça a uma distância conhecida e subtraia a diferença no código; retire ou troque a cobertura |
| Valores oscilando o tempo todo | Orçamento de tempo curto, luz ambiente, alvo pequeno | Aumente o orçamento para 50–200 ms, tire a média de várias leituras |
| 65535 e mensagem de tempo limite | Fio I2C longo ou solto, sensor reiniciado | Encurte os fios, firme as conexões, reinicie o sensor |
| Um dos dois sensores não responde de jeito nenhum | Conflito de endereço ou falta da ligação do XSHUT | Confira os pinos XSHUT, acorde os sensores em sequência e dê endereços diferentes |
| Leituras curtas demais ao ar livre | Ruído infravermelho da luz solar | Mantenha o sensor na sombra, use o perfil de alta precisão ou troque para o HC-SR04 |
Com seu tamanho pequeno, campo de visão estreito e resolução milimétrica, o VL53L0X acrescenta um olho preciso a projetos que vão de robôs a interruptores sem toque; escolhendo o perfil certo e corrigindo o offset, você obtém resultados muito mais estáveis nas distâncias curtas em que os sensores ultrassônicos têm dificuldade. No app BlueGrays, você encontra projetos de medição de distância, sensor de estacionamento, medidor de altura e robô que desvia de obstáculos com esquemas do circuito e códigos passo a passo, e pode adaptar facilmente a mesma lógica ao seu próprio projeto com o VL53L0X.
Perguntas frequentes
Até quantos metros o VL53L0X mede?
Com os ajustes padrão, o alcance confiável é de cerca de 1,2 metro. No perfil de longo alcance, em ambiente escuro e com um alvo branco que reflete bem, ele mede até 2 metros. Em superfícies cinza ou escuras e sob luz solar, esse alcance cai bastante.
O que é melhor: VL53L0X ou HC-SR04?
Depende de onde você vai usar. O VL53L0X é pequeno, tem ângulo estreito e é mais estável abaixo de 2 metros, e graças ao I2C vários sensores se ligam facilmente no mesmo barramento. O HC-SR04 mede até 4 metros, não é afetado pela luz solar e detecta vidro, mas tem dificuldade com superfícies macias como tecido.
Qual é o endereço I2C do VL53L0X e como mudá-lo?
O endereço padrão de 7 bits é 0x29; na notação de 8 bits, também aparece como 0x52. Você muda o endereço por software com setAddress(), mas a mudança não é permanente; ele volta para 0x29 quando a alimentação é cortada ou o XSHUT vai para LOW. Com vários sensores, é preciso acordá-los em sequência com o XSHUT e atribuir os endereços a cada inicialização.
Por que o VL53L0X mostra 8190?
A biblioteca da Pololu retorna um valor como 8190 ou 8191 quando o sensor não encontra nenhum retorno válido no seu campo de visão. O alvo pode estar fora do alcance, a superfície pode ser escura demais ou a fita protetora do sensor pode não ter sido retirada. Já o valor 65535 indica tempo limite do I2C; confira os fios e a alimentação.
O VL53L0X funciona sob luz solar?
Funciona, mas o desempenho cai. A luz solar tem um forte componente infravermelho, que aumenta o ruído de fundo do sensor e pode reduzir o alcance para a metade ou menos. Ao ar livre, ajuda manter o sensor na sombra, escolher o perfil de alta precisão e usá-lo em distâncias curtas.
Qual é a diferença entre o VL53L0X e o VL53L1X?
O VL53L1X é um membro mais novo da mesma família; mede até 4 metros e permite escolher só uma parte do campo de visão (ROI). O VL53L0X é limitado a 2 metros, mas é mais barato e mais do que suficiente para projetos de curto alcance. Os dois sensores usam bibliotecas diferentes, então o código não pode ser transferido de um para o outro sem alterações.
Projetos para montar depois desta leitura
Ver todos os projetos
Medição de distância com HC-SR04 (Monitor Serial)
O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

Sensor de estacionamento com HC-SR04
Uma versão em miniatura do sensor de estacionamento de um carro: quanto mais perto um objeto chega, mais rápidos ficam os bipes.

Medição de distância com display LCD
Uma ferramenta que mede distâncias sem régua: aproxime e afaste a mão na frente do sensor e veja o número mudar.

Projeto de medição de altura
Um medidor de altura preso ao batente da porta que informa, em centímetros, a altura de quem está embaixo dele.

Leitura de reflexão (proximidade) com TCRT5000
Com um pequeno sensor que emite luz invisível e mede quanto dela é refletido, você detecta a superfície à frente dele.

Robô que desvia de obstáculos
Que tal construir um veículo inteligente que encontra seu próprio caminho? O robô que desvia de obstáculos monitora o ambiente constantemente com o sensor ultrassônico na parte da frente.

Medidor ultrassônico de distância HC-SR04 com ESP32
O sensor ultrassônico HC-SR04 calcula a distância medindo o tempo que a onda sonora emitida leva para atingir um objeto e retornar (tempo de voo). Neste projeto, enviaremos um pulso de 10 microssegundos do ESP32 ao pino TRIG do sensor e leremos a duração do eco no pino ECHO com pulseIn(). Exibiremos a distância calculada em centímetros em um LCD I2C 16x2. Como o HC-SR04 opera a 5V, é preciso usar um divisor de tensão no pino ECHO; caso contrário, o GPIO de 3,3V do ESP32 será danificado.

Sensor de estacionamento com ESP32 (HC-SR04 + barra de 5 LEDs + buzzer + OLED)
A versão com ESP32 do sensor de estacionamento de carro! Usamos o sensor ultrassônico HC-SR04 para medir a distância até o objeto à sua frente. Conforme a distância diminui, a barra de 5 LEDs vai se preenchendo (verde → amarelo → vermelho) e o intervalo entre os bipes do buzzer diminui. Quando o objeto chega muito perto (menos de 10 cm), o alarme soa continuamente e todos os LEDs acendem.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

