Dans ce tutoriel, vous apprendrez à utiliser le capteur de distance laser VL6180X avec un Arduino ou tout autre microcontrôleur courant (ESP32/ESP8266) pour mesurer des distances jusqu’à 100 mm.
Le VL6180X est un capteur de distance Time-of-Flight (ToF) très compact qui utilise un laser infrarouge pour mesurer la proximité d’un objet. 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. En raison de sa portée relativement courte, il est particulièrement adapté comme capteur de proximité ou pour une simple reconnaissance de gestes.
Pièces requises
Évidemment, vous aurez besoin d’un capteur de distance VL6180X. Pour le microcontrôleur, j’ai utilisé un Arduino Uno pour ce projet, mais tout autre Arduino ou ESP32/ESP8266 conviendra également, car le capteur fonctionne en 5V ou 3,3V. Nous utiliserons aussi un écran OLED pour afficher les distances mesurées par le VL6180X.
Capteur de distance VL6180X
Arduino Uno
Câble USB pour Arduino UNO
Jeu de fils Dupont
Plaque d’essai (breadboard)
Écran 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.
Caractéristiques du VL6180X
Le VL6180X est une puce minuscule (4,8 x 2,8 x 1,0 mm) avec plusieurs ouvertures sur le dessus. L’une est pour l’émetteur laser, une autre pour le détecteur laser, et il y a aussi un détecteur de lumière ambiante. Voir l’image ci-dessous :
Le VL6180X fonctionne en émettant un faisceau laser depuis l’émetteur, en recevant la lumière réfléchie par un objet via le détecteur, puis en calculant la distance à l’objet en fonction du temps de vol de la lumière. L’image ci-dessous montre les cônes d’émission (illumination) et de réception (vue).
Voici les principales caractéristiques et spécifications techniques du VL6180X selon la fiche technique :
Notez que, bien que la fiche technique indique une portée de 100 mm, j’ai pu mesurer des distances allant jusqu’à 170 mm. En revanche, si l’objet est à moins de 10 mm, les mesures deviennent imprécises.
Schéma d’application du VL6180X
Le schéma d’application suivant montre le câblage externe nécessaire pour utiliser la puce VL6180X. Vous pouvez voir les résistances de tirage pour l’interface I2C qui connecte le VL6180X à un microcontrôleur, ainsi que deux condensateurs qui stabilisent la ligne d’alimentation 2,8 V.
SDA et SCL sont les broches pour l’interface I2C. GPIO0 est la broche d’activation de la puce. Sur des capteurs laser similaires comme VL53L1X ou VL53L0X, cette broche est appelée XSHUT (arrêt), ce qui permet d’éteindre le capteur lorsqu’elle est tirée à la masse. Cela est utile si vous souhaitez connecter plusieurs capteurs sur la même ligne I2C. GPIO1 est une broche d’interruption qui peut signaler au microcontrôleur que des données sont prêtes.
Plutôt que d’utiliser directement la petite puce VL6180X, il est préférable d’acheter une carte breakout qui intègre déjà l’électronique ci-dessus et est beaucoup plus facile à connecter.
Carte breakout pour VL6180X
L’image suivante montre la carte breakout pour le VL6180X. La puce rectangulaire au centre est le VL6180X. La carte possède aussi un régulateur de tension et des convertisseurs de niveau, ce qui permet de la connecter à des microcontrôleurs 5V ou 3,3V.
Le brochage correspond en grande partie aux broches du schéma d’application. SDA, SCL pour l’I2C, VIN et GND pour l’alimentation, et GPIO1 comme signal d’interruption. SHDN (= GPIO0, XSHUT) est la broche d’activation/arrêt de la puce. Enfin, 2v8 est la sortie 2,8 V du régulateur intégré, capable de fournir jusqu’à 100 mA.
Connexion du VL6180X à l’Arduino
Grâce à l’interface I2C du VL6180X, le connecter à un Arduino est simple. D’abord, connectez les broches SCL et SDA de la carte breakout VL6180X aux broches correspondantes de l’Arduino comme montré ci-dessous. Ensuite, reliez la masse à GND et le 3,3 V à VIN du VL6180X, et c’est prêt.
La carte breakout VL6180X fonctionne en 5V ou 3,3V, vous pouvez utiliser l’un ou l’autre pour VIN. Passons maintenant à l’écriture du code pour tester le fonctionnement du capteur VL6180X.
Code pour mesurer la distance avec VL6180X
Avant de pouvoir mesurer des distances avec le capteur VL6180X, vous devrez installer une bibliothèque. Les plus courantes sont la Adafruit VL6180X Library et la VL6180X library by Pololu. J’ai cependant rencontré des problèmes avec les bibliothèques Adafruit lors de la rédaction du tutoriel pour le VL53L0X Distance Sensor, et j’utiliserai donc la VL6180X library by Pololu.
Installation de la bibliothèque VL6180X par Pololu
Pour installer la VL6180X library by Pololu, il suffit de chercher VL6180X, trouver celle de Pololu et l’installer via le Library Manager. L’image ci-dessous montre à quoi cela ressemble une fois la bibliothèque installée :
Avec la bibliothèque installée, testons le capteur. Le code suivant lit les distances mesurées par le VL6180X et les affiche dans le moniteur série.
#include "Wire.h"
#include "VL6180X.h"
VL6180X sensor;
void setup() {
Serial.begin(9600);
Wire.begin();
sensor.init();
sensor.configureDefault();
sensor.setTimeout(500);
}
void loop() {
Serial.println(sensor.readRangeSingleMillimeters());
delay(1000);
}
Examinons de plus près le code exemple ci-dessus.
Inclusion des bibliothèques
La première partie du code inclut les bibliothèques nécessaires à la communication avec le capteur.
#include "Wire.h" #include "VL6180X.h"
La bibliothèque Wire.h est utilisée pour la communication I2C, qui est la façon dont l’Arduino communique avec le capteur VL6180X. La bibliothèque VL6180X.h contient les fonctions et définitions spécifiques au capteur VL6180X, facilitant son utilisation.
Création d’un objet capteur
Ensuite, nous créons une instance de la classe VL6180X.
VL6180X sensor;
Cette ligne déclare une variable nommée sensor que nous utiliserons pour accéder aux méthodes fournies par la bibliothèque VL6180X.
Fonction Setup
Dans la fonction setup(), nous initialisons la communication série et le capteur.
void setup() {
Serial.begin(9600);
Wire.begin();
sensor.init();
sensor.configureDefault();
sensor.setTimeout(500);
}
Serial.begin(9600)initialise la communication série à un débit de 9600 bauds, ce qui nous permet d’envoyer des données au moniteur série.Wire.begin()initialise le bus I2C, permettant la communication avec le capteur.sensor.init()initialise le capteur VL6180X, le préparant à fonctionner.sensor.configureDefault()configure le capteur avec les réglages par défaut, assurant une configuration correcte pour la mesure de distance.sensor.setTimeout(500)définit un délai d’attente pour les lectures du capteur à 500 millisecondes. Si le capteur ne répond pas dans ce délai, une erreur sera retournée.
Fonction Loop
La fonction loop() lit continuellement la distance du capteur et l’affiche dans le moniteur série.
void loop() {
Serial.println(sensor.readRangeSingleMillimeters());
delay(1000);
}
La fonction readRangeSingleMillimeters() lit la distance mesurée par le capteur et la retourne en millimètres. Cette valeur est ensuite affichée dans le moniteur série. Si le capteur ne détecte aucun objet (hors portée), une valeur de 255 sera affichée. La capture d’écran suivante montre quelques mesures d’exemple dans le moniteur série :
La fonction delay(1000) met le programme en pause pendant 1000 millisecondes (1 seconde) avant la lecture suivante, ralentissant ainsi la fréquence des mesures.
Dans la section suivante, nous allons ajouter un écran OLED à notre circuit et afficher les distances dessus, au lieu de les imprimer dans le moniteur série.
Ajout d’un écran OLED pour afficher les données du VL6180X
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 VL6180X. Et comme l’OLED fonctionne en 3,3 V, nous pouvons aussi partager les lignes d’alimentation.
Code pour afficher les distances mesurées par le VL6180X sur OLED
Le code suivant lit les mesures de distance du capteur VL6180X et les affiche sur l’OLED. Jetez d’abord un coup d’œil au code complet, puis nous en discuterons les détails.
#include "Wire.h"
#include "VL6180X.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
VL6180X sensor;
void sensor_init() {
Wire.begin();
sensor.init();
sensor.configureDefault();
sensor.setTimeout(500);
}
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
void display() {
static char text[30];
int dist = sensor.readRangeSingleMillimeters();
sprintf(text, "%4d mm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
oled.display();
}
void setup() {
oled_init();
sensor_init();
}
void loop() {
display();
}
Décomposons le code en parties pour mieux le comprendre.
Bibliothèques incluses
Au début du code, nous incluons les bibliothèques nécessaires à la communication I2C (Wire), au capteur VL6180X, et à l’écran OLED Adafruit SSD1306.
#include "Wire.h" #include "VL6180X.h" #include "Adafruit_SSD1306.h"
Si vous n’avez pas encore installé la Adafruit_SSD1306 Library, vous devrez le faire. Installez-la simplement via le Library Manager comme d’habitude :
Initialisation des objets
Nous créons des instances de l’écran OLED et du capteur VL6180X. L’écran OLED est initialisé avec une largeur de 128 pixels et une hauteur de 64 pixels.
Adafruit_SSD1306 oled(128, 64, &Wire, -1); VL6180X sensor;
Fonction d’initialisation du capteur
La fonction sensor_init() initialise la communication I2C et configure le capteur VL6180X avec les réglages par défaut. Elle définit aussi un délai d’attente de 500 millisecondes pour les lectures du capteur.
void sensor_init() {
Wire.begin();
sensor.init();
sensor.configureDefault();
sensor.setTimeout(500);
}
Fonction d’initialisation de l’OLED
La fonction oled_init() initialise l’écran OLED. Elle configure l’écran pour utiliser la pompe de charge interne et spécifie l’adresse I2C (0x3C). La taille du texte est réglée à 2, et la couleur du texte est blanche.
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
Notez que l’adresse I2C de l’écran OLED est définie à 0x3C dans oled.begin(). La plupart de ces petits OLED utilisent cette adresse, mais la vôtre peut être différente. Si vous ne voyez rien sur l’OLED, il est probable qu’il ait une adresse I2C différente 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.
Fonction d’affichage
La fonction display() lit la distance du capteur en millimètres et la formate en chaîne de caractères. Elle efface ensuite l’écran OLED, positionne le curseur, affiche la distance, et met à jour l’affichage.
void display() {
static char text[30];
int dist = sensor.readRangeSingleMillimeters();
sprintf(text, "%4d mm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
oled.display();
}
Si le capteur ne détecte pas d’objet, car il est hors portée, une valeur de 255 mm sera affichée sur l’OLED :
Fonction Setup
Dans la fonction setup(), nous appelons les fonctions d’initialisation pour l’écran OLED et le capteur afin de les préparer à l’utilisation.
void setup() {
oled_init();
sensor_init();
}
Fonction Loop
Enfin, la fonction loop() appelle continuellement la fonction display(), permettant de mettre à jour en temps réel les mesures de distance affichées sur l’OLED.
void loop() {
display();
}
Le court clip vidéo suivant montre le capteur VL6180X et l’affichage en action :
Conclusions
Dans ce tutoriel, vous avez appris à utiliser le capteur de distance VL6180X avec un Arduino pour mesurer des distances et les afficher sur un écran OLED.
Le capteur VL6180X est un capteur très compact qui utilise un laser infrarouge pour mesurer des distances. Le VL6180X est similaire aux capteurs VL53L1X, VL53L0X et TOF10120 mais a une portée plus courte. Si vous avez besoin d’un capteur pour une portée beaucoup plus grande, regardez le TF Luna qui peut mesurer des distances jusqu’à 8 mètres.
Il est plus adapté comme capteur de proximité ou de gestes simples que comme télémètre longue portée. Il est aussi équipé d’un capteur de lumière ambiante intégré, bien que je n’aie pas réussi à obtenir de lecture de ce capteur avec la bibliothèque VL6180X de Pololu.
Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.
Bon bricolage ; )
