Neste tutorial, vais aprender a usar o Sensor de Distância a Laser TF-Luna com um Arduino ou qualquer outro microcontrolador comum (ESP32/ESP8266) para medir distâncias.
O TF-Luna é um sensor LiDAR/Proximidade compacto e preciso que mede distâncias até 8 metros. Utiliza luz laser infravermelha e o princípio do Tempo de Voo (ToF). Ao medir o tempo que a luz demora a refletir num objeto, consegue calcular distâncias com alta precisão e rapidez.
Neste guia, vamos abordar a configuração, a ligação e a programação necessárias para pôr o teu TF-Luna a funcionar com Arduino.
Peças Necessárias
Vais precisar de um Sensor TF-Luna (listado abaixo). Quanto ao microcontrolador, usei um Arduino Uno para este projeto, mas qualquer outro Arduino ou ESP32/ESP8266 também serve. Também vamos usar um OLED para mostrar as distâncias medidas pelo TF-Luna num pequeno ecrã.
Sensor de Distância TF-Luna
Arduino Uno
Cabo USB para Arduino UNO
Conjunto de Fios Dupont
Breadboard
Ecrã OLED
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Características do TF-Luna
O sensor TF-Luna usa o princípio do Tempo de Voo (TOF) para medir distâncias. Emite periodicamente ondas moduladas em infravermelho próximo e calcula o tempo medindo a diferença de fase entre a
onda original e a onda refletida. Vê a ilustração abaixo:
O alcance de operação (interior) do sensor é de 0,2m a 8m com uma precisão de ±6cm@ (0,2-3m) ou ±2%@ (3m-8m) e uma resolução de 1 cm. O TF-Luna necessita de 3,7V-5,2V como fonte de alimentação e a corrente média é cerca de 70mA, com picos até 150mA. A comunicação é via UART ou I2C. Para mais detalhes, consulta a folha de dados abaixo:
TF-Luna como parte de um sistema LiDAR
Existem muitas aplicações para sensores de distância a laser, como aviso de proximidade em estacionamento, deteção de intrusos, desvio de obstáculos em robótica e mais. O mais importante é que sensores de distância a laser são usados frequentemente em LiDAR sistemas, que significa Luz Deteção e Rangeamento e são usados para criar mapas e modelos 3D altamente precisos.
Além do sensor de distância a laser, um sistema LiDAR normalmente inclui uma unidade GPS e uma unidade de medição inercial (IMU). O scanner é um mecanismo que move o feixe laser por uma área ampla, permitindo ao sistema captar dados de diferentes ângulos e posições. A unidade GPS fornece dados de localização precisos. Finalmente, a IMU acompanha a orientação e o movimento do sistema LiDAR, crucial para manter a precisão durante a varredura.
À medida que os pulsos laser são emitidos e refletidos, o sistema regista continuamente as medições de distância juntamente com os seus ângulos e posições correspondentes. Estes dados são usados para criar uma nuvem de pontos, que representa a distribuição espacial dos objetos na área escaneada.
Podes construir um LiDAR simples tu mesmo, fixando o sensor de distância a laser num servo e usar o servo para escanear o ambiente, enquanto o sensor mede as distâncias. Contudo, neste tutorial vamos usar apenas o sensor de distância a laser, sem dispositivo de varredura.
Pinout do TF-Luna
O TF-Luna tem 6 pinos. A imagem abaixo mostra o lado do sensor com o conector e os seus seis pinos:
O Pino 1 (5V) e o Pino 4 (GND) são para a alimentação. Os pinos 2 e 3 são para comunicação I2C ou UART. O protocolo usado depende do estado do Pino 5 (CFG). Se ligado a terra, o I2C é ativado. O Pino 6 (MUX) fornece um sinal de dados prontos, se o I2C estiver ativado.
Nota que o cabo do conector que normalmente acompanha o sensor TF-Luna usa cores arbitrárias. Não confies nas cores para deduzir qual fio vai para qual pino do Arduino.
Ligação do TF-Luna
O sensor TF-Luna pode comunicar via UART ou I2C. Vamos usar a interface I2C. Primeiro, liga o pino 1 (VCC) do TF-Luna à saída 5V do Arduino. Depois liga o SDA (pino 2) do TF-Luna ao pino SDA do Arduino. Em seguida, liga o SCL (pino 3) do TF-Luna ao SCL do Arduino.
Finalmente, precisas de ligar os pinos 4 e 5 do TF-Luna ao terra (GND). O pino 6 fica sem ligação. Vê o diagrama completo de ligações abaixo:
A tabela seguinte lista todas as ligações que precisas de fazer.
| TF-Luna | Arduino |
|---|---|
| Pino 1 (VCC) | 5V |
| Pino 2 (SDA) | SDA |
| Pino 3 (SCL) | SCL |
| Pino 4 (GND) | GND |
| Pino 5 (CFG) | GND |
| Pino 6 (MUX) | sem ligação |
Nota que o TF-Luna requer 5V para alimentação. Ao contrário de muitos outros pequenos sensores IR de distância, não funciona com 3,3V.
No entanto, podes usá-lo com um microcontrolador de 3,3V, por exemplo um ESP32. Só tens de garantir que usas a saída de 5V ou outra fonte de alimentação de 5V. A imagem abaixo mostra como ligar o TF-Luna a um ESP32 C3 Mini, por exemplo:
Na próxima secção vamos escrever um código simples para testar o sensor.
Código para medir distâncias com TF-Luna
Antes de poderes medir distâncias com o sensor TF-Luna, terás de instalar uma biblioteca. Vamos usar a TFL22C library by Bud Ryerson. Para a instalar, abre o Library Manager, procura por “TFLuna”, encontra a biblioteca do Bud Ryerson e instala-a clicando no botão “INSTALL”.
Com a biblioteca instalada, vamos testar o sensor. O código seguinte lê as distâncias medidas pelo sensor TF-Luna e imprime-as no monitor serial.
#include "Wire.h"
#include "TFLI2C.h"
TFLI2C sensor;
void setup() {
Serial.begin(9600);
Wire.begin();
}
void loop() {
int16_t dist;
if (sensor.getData(dist, 0x10)) {
Serial.print("dist:");
Serial.println(dist);
}
delay(100);
}
O código começa por incluir as bibliotecas necessárias para comunicação I2C e para o sensor TF-Luna.
#include "Wire.h" #include "TFLI2C.h"
A Wire.h biblioteca é usada para comunicação I2C, enquanto a TFLI2C.h é uma biblioteca específica para interface com o sensor TF-Luna.
De seguida, criamos uma instância da classe TFLI2C que representa o nosso sensor de distância.
TFLI2C sensor;
Função setup
Na função setup(), inicializamos a comunicação Serial e o barramento I2C.
void setup() {
Serial.begin(9600);
Wire.begin();
}
O comando Serial.begin(9600) inicializa o Monitor Serial a uma taxa de 9600 bps, permitindo enviar e receber dados. O comando Wire.begin() inicializa o barramento I2C, permitindo a comunicação com o sensor.
Função loop
Na função loop(), lemos continuamente os dados de distância do sensor.
void loop() {
int16_t dist;
if (sensor.getData(dist, 0x10)) {
Serial.print("dist:");
Serial.println(dist);
}
delay(100);
}
Aqui, declaramos uma variável dist do tipo int16_t para guardar o valor da distância. A função sensor.getData(dist, 0x10) tenta ler os dados de distância do sensor. Se a chamada getData() falhar, podes consultar os significados dos códigos error codes no ficheiro header da biblioteca.
O segundo parâmetro 0x10 é o endereço I2C padrão do sensor. O sensor TF-Luna tem um endereço I2C configurável (0x08 … 0x77). Se quiseres alterá-lo, podes usar a função Set_I2C_Addr().
Se os dados forem obtidos com sucesso, imprimimos o valor da distância no Monitor Serial usando Serial.print() e Serial.println(). O comando delay(100) introduz uma pausa de 100 milissegundos antes da próxima leitura.
Este ciclo corre indefinidamente, medindo e mostrando continuamente a distância detetada pelo sensor TF-Luna. Se carregares e executares o código, deverás ver as distâncias medidas em centímetros impressas no Monitor Serial:
O sensor TF-Luna pode medir distâncias até 8 m (=800 cm). Para além disso, o código imprime uma distância de 900, indicando que nenhum objeto foi detetado.
Abaixo algumas medições de distância do TF-Luna mostradas no Serial Plotter ao mover a minha mão mais perto e mais longe:
Na próxima secção vamos adicionar um OLED ao nosso circuito e mostrar as distâncias nele, em vez de imprimir no Monitor Serial.
Adicionar um OLED para mostrar os dados de distância do TF-Luna
Como o OLED também é um dispositivo I2C, a ligação é simples. Ligamos o SDA e o SCL aos mesmos pinos onde o sensor TF-Luna está ligado. E como o OLED pode funcionar a 5V, podemos também partilhar as linhas de alimentação.
Código para mostrar distâncias medidas pelo TF-Luna no OLED
O código seguinte lê as medições de distância do sensor TF-Luna e mostra-as no OLED. Dá uma vista de olhos ao código completo primeiro, depois discutimos os detalhes.
#include "Wire.h"
#include "TFLI2C.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
TFLI2C sensor;
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
void display() {
static char text[30];
static int16_t dist;
if (sensor.getData(dist, 0x10)) {
sprintf(text, "%4d cm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
oled.display();
}
}
void setup() {
Wire.begin();
oled_init();
}
void loop() {
display();
delay(100);
}
Bibliotecas e Inicialização do Ecrã
Começamos por incluir a biblioteca Wire para comunicação I2C, a TFL22C library para o sensor e a Adafruit_SSD1306 Library para o ecrã OLED. Depois criamos o objeto oled e o objeto sensor.
#include "Wire.h" #include "TFLI2C.h" #include "Adafruit_SSD1306.h" Adafruit_SSD1306 oled(128, 64, &Wire, -1); TFLI2C sensor;
Se ainda não instalaste a Adafruit_SSD1306 Library, terás de o fazer. Basta instalar via Library Manager como habitual:
oled_initFunção setup
A função oled_init() inicializa o ecrã, limpa-o, define o tamanho do texto e a cor do texto.
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.clearDisplay();
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
Nota que o endereço I2C para o ecrã OLED está definido para 0x3C em oled.begin(). A maioria destes pequenos OLEDs usa este endereço (or 0x27), mas o teu pode ser diferente. Se não vês nada no OLED, provavelmente tem um endereço I2C diferente e terás de alterar o endereço.
Se não souberes o endereço I2C, consulta o tutorial How to Interface the SSD1306 I2C OLED Graphic Display With Arduino para o descobrir. Também o tutorial Use SSD1306 I2C OLED Display With Arduino te ensinará mais sobre como usar um OLED.
Função display
A função display() chama sensor.getData() para obter a leitura de distância do sensor TF-Luna. Depois limpa o ecrã e imprime a distância. A função sprintf() é usada para converter o valor da distância num texto formatado.
void display() {
static char text[30];
static int16_t dist;
if (sensor.getData(dist, 0x10)) {
sprintf(text, "%4d cm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
oled.display();
}
}
Se colocares um objeto à frente do sensor, o ecrã deverá mostrar a distância medida em centímetros. Vê o exemplo de saída abaixo.
Função setup
Na função setup(), primeiro chamamos Wire.begin() para iniciar a comunicação I2C, e depois chamamos oled_init(), que inicializa o OLED.
void setup() {
Wire.begin();
oled_init();
}
Função loop
A função loop() simplesmente chama a função display() a cada 100 ms.
void loop() {
display();
delay(100);
}
E é tudo. Com o TF-Luna podes medir distâncias entre 3 cm e 800 cm, embora distâncias abaixo de 20 cm não sejam muito precisas.
Conclusões
Neste tutorial aprendeste a usar o Sensor de Distância TF-Luna com um Arduino para medir distâncias e mostrá-las num OLED.
Ao contrário de outros sensores Time-of-Flight como o VL53L0X, o VL53L1X, ou o TOF10120, o TF-Luna é maior, precisa de 5V para alimentação, mas tem um alcance muito maior. No entanto, a resolução é apenas em centímetros (não milímetros) e o sensor é mais caro. Se precisares de ainda mais alcance e estiveres disposto a gastar mais, dá uma vista de olhos no TFmini-S, que tem um alcance até 12 m!
Outros sensores comuns de distância infravermelhos como o GP2Y0A710K0F ou o GP2Y0A21YK0F são semelhantes em tamanho mas usam triangulação para determinar a distância com base no ângulo da luz IR refletida e têm um alcance muito mais curto.
O TF-Luna é mais adequado para deteção de objetos a longa distância em ambientes exteriores. Nota, porém, que a parte traseira do sensor não é encapsulada e terás de proteger a sua eletrónica quando o usares ao ar livre.
Se tiveres alguma dúvida, sente-te à vontade para deixar nos comentários.
Boas experiências ; )
