Capteur de distance TF-Luna avec Arduino

Dans ce tutoriel, vous apprendrez à utiliser le capteur de distance laser TF-Luna avec un Arduino ou tout autre microcontrôleur courant (ESP32/ESP8266) pour mesurer des distances.

Le TF-Luna est un capteur LiDAR/Proximité compact et précis qui mesure des distances jusqu’à 8 mètres. Il utilise une lumière laser infrarouge et le principe du Time-of-Flight (ToF). En mesurant le temps que met la lumière à être réfléchie par un objet, il peut calculer des distances avec une grande précision et rapidité.

Dans ce guide, nous verrons la configuration, le câblage et le codage nécessaires pour faire fonctionner votre TF-Luna avec Arduino.

Pièces requises

Vous aurez besoin d’un capteur TF-Luna (listé ci-dessous). Pour le microcontrôleur, j’ai utilisé un Arduino Uno pour ce projet, mais tout autre Arduino ou ESP32/ESP8266 fonctionnera aussi. Nous utiliserons également un écran OLED pour afficher les distances mesurées par le TF-Luna.

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.

Caractéristiques du TF-Luna

Le capteur TF-Luna utilise le principe du Time of Flight (TOF) pour mesurer les distances. Il émet périodiquement des ondes modulées dans l’infrarouge proche et calcule le temps en mesurant la différence de phase entre la
onde originale et l’onde réfléchie. Voir l’illustration ci-dessous :

La plage de fonctionnement (en intérieur) du capteur est de 0,2 m à 8 m avec une précision de ±6 cm @ (0,2-3 m) ou ±2 % @ (3-8 m) et une résolution de 1 cm. Le TF-Luna nécessite une alimentation de 3,7 V à 5,2 V et consomme en moyenne environ 70 mA, avec un pic pouvant atteindre 150 mA. La communication se fait via UART ou I2C. Pour plus de détails, consultez la fiche technique ci-dessous :

TF-Luna dans un système LiDAR

Les capteurs de distance laser ont de nombreuses applications telles que l’alerte de proximité de stationnement, la détection d’intrus, l’évitement d’obstacles en robotique, et plus encore. Surtout, les capteurs laser sont couramment utilisés dans les LiDAR systèmes, qui signifieLight Detection etRanging et servent à créer des cartes et modèles 3D très précis.

En plus du capteur laser, un système LiDAR comprend généralement une unité GPS et une unité de mesure inertielle (IMU). Le scanner est un mécanisme qui déplace le faisceau laser sur une large zone, permettant au système de capturer des données sous différents angles et positions. L’GPSunité GPS fournit des données de localisation précises. Enfin, l’IMU suit l’orientation et le mouvement du système LiDAR, ce qui est crucial pour maintenir la précision lors du balayage.

Au fur et à mesure que les impulsions laser sont émises et réfléchies, le système enregistre continuellement les mesures de distance ainsi que leurs angles et positions correspondants. Ces données sont ensuite utilisées pour créer un nuage de points, représentant la distribution spatiale des objets dans la zone scannée.

Vous pouvez construire un LiDAR simple vous-même en fixant le capteur laser sur un servo et en utilisant ce servo pour scanner l’environnement, tandis que le capteur mesure les distances. Cependant, dans ce tutoriel, nous utiliserons uniquement le capteur laser, sans dispositif de balayage.

Brochage du TF-Luna

Le TF-Luna possède 6 broches. L’image ci-dessous montre le côté du capteur avec le connecteur et ses six broches :

La broche 1 (5V) et la broche 4 (GND) sont pour l’alimentation. Les broches 2 et 3 servent à la communication I2C ou UART. Le protocole utilisé dépend de l’état de la broche 5 (CFG). Si elle est reliée à la masse, l’I2C est activé. La broche 6 (MUX) fournit un signal de données prêtes si l’I2C est activé.

Notez que le câble de connexion fourni avec le capteur TF-Luna utilise des couleurs arbitraires. Ne vous fiez pas aux couleurs pour déterminer quel câble va à quelle broche Arduino.

Connexion du TF-Luna

Le capteur TF-Luna peut communiquer via UART ou I2C. Nous allons utiliser l’interface I2C. Commencez par connecter la broche 1 (VCC) du TF-Luna à la sortie 5V de l’Arduino. Ensuite, connectez SDA (broche 2) du TF-Luna à la broche SDA de l’Arduino. Puis connectez SCL (broche 3) du TF-Luna à la broche SCL de l’Arduino.

Enfin, vous devez connecter les broches 4 et 5 du TF-Luna à la masse (GND). La broche 6 reste non connectée. Voir le schéma de câblage complet ci-dessous :

Le tableau suivant liste toutes les connexions à réaliser.

TF-Luna	Arduino
Broche 1 (VCC)	5V
Broche 2 (SDA)	SDA
Broche 3 (SCL)	SCL
Broche 4 (GND)	GND
Broche 5 (CFG)	GND
Broche 6 (MUX)	non connectée

Notez que le TF-Luna nécessite une alimentation en 5V. Contrairement à beaucoup d’autres petits capteurs de distance IR, il ne fonctionnera pas en 3,3V.

Cependant, vous pouvez l’utiliser avec un microcontrôleur 3,3V, par exemple un ESP32. Assurez-vous simplement d’utiliser la sortie 5V ou une autre source d’alimentation en 5V. L’image ci-dessous montre comment connecter le TF-Luna à un ESP32 C3 Mini, par exemple :

Dans la section suivante, nous allons écrire un code simple pour tester le capteur.

Code pour mesurer les distances avec TF-Luna

Avant de pouvoir mesurer des distances avec le capteur TF-Luna, vous devez installer une bibliothèque. Nous allons utiliser la TFL22C library by Bud Ryerson. Pour l’installer, ouvrez le Library Manager, cherchez « TFLuna », trouvez la bibliothèque de Bud Ryerson et installez-la en cliquant sur le bouton « INSTALL ».

Une fois la bibliothèque installée, testons le capteur. Le code suivant lit les distances mesurées par le capteur TF-Luna et les affiche dans le moniteur série.

#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);
}

Le code commence par inclure les bibliothèques nécessaires à la communication I2C et au capteur TF-Luna.

#include "Wire.h"    
#include "TFLI2C.h"  

La Wire.h est utilisée pour la communication I2C, tandis que TFLI2C.h est une bibliothèque spécifique pour interfacer le capteur TF-Luna.

Ensuite, nous créons une instance de la classe TFLI2C qui représente notre capteur de distance.

TFLI2C sensor;

Fonction setup

Dans la fonction setup(), nous initialisons la communication série et le bus I2C.

void setup() {
  Serial.begin(9600);  
  Wire.begin();          
}

La commande Serial.begin(9600) initialise le moniteur série à un débit de 9600 bps, ce qui nous permet d’envoyer et de recevoir des données. La commande Wire.begin() initialise le bus I2C, permettant la communication avec le capteur.

Fonction loop

Dans la fonction loop(), nous lisons continuellement les données de distance du capteur.

void loop() {
  int16_t dist; 
  if (sensor.getData(dist, 0x10)) {
    Serial.print("dist:");
    Serial.println(dist);
  }
  delay(100);
}

Ici, nous déclarons une variable dist de type int16_t pour stocker la valeur de la distance. La fonction sensor.getData(dist, 0x10) tente de lire la distance depuis le capteur. Si l’appel getData() échoue, vous pouvez trouver la signification des codes error codes dans le fichier d’en-tête de la bibliothèque.

Le second paramètre 0x10 est l’adresse I2C par défaut du capteur. Le TF-Luna a une adresse I2C configurable (0x08 … 0x77). Si vous souhaitez la modifier, vous pouvez appeler la fonction Set_I2C_Addr().

Si les données sont récupérées avec succès, nous affichons la distance dans le moniteur série avec Serial.print() et Serial.println(). La commande delay(100) introduit une pause de 100 millisecondes avant la lecture suivante.

Cette boucle tourne indéfiniment, mesurant et affichant continuellement la distance détectée par le capteur TF-Luna. Si vous téléversez et lancez le code, vous devriez voir les distances mesurées en centimètres s’afficher dans le moniteur série :

Le capteur TF-Luna peut mesurer des distances jusqu’à 8 m (=800 cm). Au-delà, le code affichera une distance de 900, indiquant qu’aucun objet n’a été détecté.

Voici quelques mesures de distance du TF-Luna affichées sur le traceur série lorsque je rapproche et éloigne ma main :

Dans la section suivante, nous allons ajouter un écran OLED à notre circuit pour afficher les distances dessus, au lieu de les imprimer dans le moniteur série.

Ajout d’un écran OLED pour afficher les données de distance du TF-Luna

Comme l’OLED est aussi un périphérique I2C, le connecter est simple. Il suffit de relier SDA et SCL aux mêmes broches que le capteur TF-Luna. Et comme l’OLED peut fonctionner en 5V, nous pouvons aussi partager les lignes d’alimentation.

Code pour afficher les distances mesurées par TF-Luna sur OLED

Le code suivant lit les mesures de distance du capteur TF-Luna et les affiche sur l’OLED. Jetez d’abord un œil au code complet, puis nous en discuterons les détails.

#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);
}

Bibliothèques et initialisation de l’affichage

Nous commençons par inclure la bibliothèque Wire pour la communication I2C, TFL22C library pour le capteur et Adafruit_SSD1306 Library pour l’écran OLED. Nous créons ensuite l’objet oled et l’objet sensor.

#include "Wire.h"
#include "TFLI2C.h"
#include "Adafruit_SSD1306.h"

Adafruit_SSD1306 oled(128, 64, &Wire, -1);
TFLI2C sensor;

Si vous n’avez pas encore installé la Adafruit_SSD1306 Library, vous devrez le faire. Installez-la via le Library Manager comme d’habitude :

oled_initFonction setup

La fonction oled_init() initialise l’écran, le nettoie, définit la taille du texte et la couleur.

void oled_init() {
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.clearDisplay();
  oled.setTextSize(2);
  oled.setTextColor(WHITE);
}

Notez que l’adresse I2C de l’écran OLED est réglée sur 0x3C dans oled.begin(). La plupart de ces petits OLED utilisent cette adresse (or 0x27) mais la vôtre peut être différente. Si vous ne voyez rien sur l’OLED, il est probable qu’il ait une autre adresse I2C et vous devrez la modifier.

Si vous ne connaissez pas l’adresse I2C, consultez le tutoriel How to Interface the SSD1306 I2C OLED Graphic Display With Arduino pour la trouver. Le tutoriel Use SSD1306 I2C OLED Display With Arduino vous expliquera aussi comment utiliser un OLED.

Fonction display

La fonction display() appelle sensor.getData() pour obtenir la lecture de distance du capteur TF-Luna. Elle efface ensuite l’écran et affiche la distance. La fonction sprintf() est utilisée pour convertir la valeur de distance en texte formaté.

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();
  }
}

Si vous placez un objet devant le capteur, l’écran devrait afficher la distance mesurée en centimètres. Voir l’exemple ci-dessous.

Fonction setup

Dans la fonction setup(), nous appelons d’abord Wire.begin() pour démarrer la communication I2C, puis oled_init(), qui initialise l’OLED.

void setup() {
  Wire.begin();
  oled_init();
}

Fonction loop

La fonction loop() appelle simplement la fonction display() toutes les 100 ms.

void loop() {
  display();
  delay(100);
}

Et voilà. Avec le TF-Luna, vous pouvez mesurer des distances de 3 cm à 800 cm, même si les mesures en dessous de 20 cm sont moins précises.

Conclusions

Dans ce tutoriel, vous avez appris à utiliser le capteur de distance TF-Luna avec un Arduino pour mesurer des distances et les afficher sur un écran OLED.

Contrairement à d’autres capteurs Time-of-Flight comme le VL53L0X, le VL53L1X, ou le TOF10120, le TF-Luna est plus grand, nécessite une alimentation 5V, mais offre une portée beaucoup plus grande. Cependant, la résolution est seulement au centimètre (pas au millimètre) et le capteur est plus cher. Si vous avez besoin d’une portée encore plus grande et êtes prêt à investir plus, regardez le TFmini-S, qui atteint jusqu’à 12 m !

D’autres capteurs infrarouges courants comme le GP2Y0A710K0F ou le GP2Y0A21YK0F sont de taille similaire mais utilisent la triangulation pour déterminer la distance en fonction de l’angle de la lumière IR réfléchie et ont une portée beaucoup plus courte.

Le TF-Luna est le plus adapté pour la détection longue portée d’objets en extérieur. Notez cependant que l’arrière du capteur n’est pas encapsulé et que vous devrez protéger son électronique si vous l’utilisez en extérieur.

Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.

Bon bricolage ; )