Dans ce tutoriel, vous apprendrez comment construire un capteur de stationnement avec le TOF10120 IR Laser Distance Sensor et un CrowPanel 3.5″ ESP32 Display . Un capteur de stationnement aide les conducteurs à éviter les obstacles lors du stationnement, par exemple en mesurant la distance entre la voiture et le mur du garage.
La courte vidéo ci-dessous montre le capteur de stationnement. Elle illustre comment les distances sont mesurées en centimètres, et comment régler la distance pour l’alarme de proximité (couleur rouge) :
Le capteur TOF10120 utilise la technologie de temps de vol. Il émet un faisceau laser infrarouge et mesure le temps que met ce faisceau à revenir après avoir frappé un objet. Ce temps est converti en distance.
Le microcontrôleur ESP32 intégré dans le CrowPanel Display traite ensuite les données du capteur TOF10120. Il calcule la distance et prépare l’information pour l’affichage.
Enfin, l’écran TFT du CrowPanel affiche la distance en temps réel. Il fournit la sortie visuelle, permettant au conducteur de voir à quelle distance il se trouve des obstacles.
Dans les sections suivantes, vous apprendrez comment connecter le capteur TOF10120 au CrowPanel Display et comment le programmer pour afficher les informations de distance. Commençons par les pièces nécessaires.
Pièces requises
En plus du capteur TOF10120, vous aurez besoin du CrowPanel 3.5″ ESP32 Display d’ELECROW et de l’IDE Arduino. Quelques câbles Dupont pour connecter le capteur et l’écran seront également utiles.
Capteur de distance TOF10120
CrowPanel 3.5″ ESP32 Display
Kit de câbles Dupont
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 CrowPanel 3.5″ ESP32 Display
Le CrowPanel 3.5″ ESP32 Display est un écran tactile résistif avec un affichage TFT en résolution 480*320 et un ESP32-WROVER-B intégré comme processeur de contrôle. Vous pouvez obtenir l’écran avec un boîtier en acrylique (voir photo ci-dessous), ce qui signifie que vous n’avez pas besoin de fabriquer un boîtier vous-même.
De plus, la carte est équipée d’un emplacement pour carte TF, d’une interface UART, d’une interface I2C, d’une interface haut-parleur, d’un connecteur batterie avec fonction de charge et d’un petit port GPIO avec deux broches GPIO. Voir le brochage ci-dessous :
Le tableau suivant liste les broches GPIO assignées aux trois interfaces IO.
| GPIO_D | IO25 ; IO32 |
| UART | RX(IO16) ; TX(IO17) |
| I2C | SDA(IO22) ; SCL(IO21) |
La carte peut être alimentée via le port USB (5V, 2A) ou en connectant une batterie LiPo standard 3,7V au connecteur BAT. Faites juste attention à la polarité du connecteur et de la batterie. Si le câble USB et la batterie sont connectés en même temps, la carte chargera la batterie (courant de charge max 500mA).
Vous pouvez programmer la carte avec divers environnements de développement comme Arduino IDE, Espressif IDF, Lua RTOS et Micro Python, et elle est compatible avec le LVGL graphics library . Cependant, dans ce tutoriel, nous utiliserons Arduino IDE et le TFT_eSPI graphics library .
Caractéristiques du TOF10120
Le capteur de distance TOF10120 Time-of-Flight est un capteur très petit (10mm x 13mm), de haute précision, qui utilise la lumière infrarouge pour mesurer les distances.
Il est basé sur le principe du temps de vol (ToF), où le capteur émet des impulsions lumineuses et mesure le temps que met la lumière à revenir pour calculer la distance. Le TOF10120 a une portée allant jusqu’à 180 cm et fonctionne à une longueur d’onde de 940 nm. L’image ci-dessous montre le cône de la LED laser qui émet l’impulsion lumineuse et le cône de vue du détecteur qui enregistre la lumière réfléchie.
Le TOF10120 fonctionne sous 3V à 5V, avec une consommation moyenne faible de seulement 35 mA. La liste suivante résume ses principales caractéristiques :
- Plage de fonctionnement : 100-1800 mm
- Erreur de mesure : jusqu’à 5 %
- Mesure rapide : max 30 ms
- Interface de communication : UART / I2C
- Paramètres de transmission UART : 9600 8n1
- Longueur d’onde : 940 nm
- Champ de vision : 25°
- Immunité à la lumière ambiante : 50k lux
- Plage de tension : 3V à 5V
- Consommation moyenne : 35 mA
La spécification ci-dessus et la fiche technique indiquent que la distance minimale mesurable est de 100 mm. Cependant, j’ai constaté que vous pouvez obtenir des mesures aussi proches que 10 mm et aussi loin que 2000 mm, mais en dessous de 30 mm les mesures deviennent très imprécises.
Le TOF10120 communique avec les microcontrôleurs via une interface I2C ou UART. L’image ci-dessous montre le brochage. SDA et SCL sont pour l’interface I2C, et RxD et TxD pour la communication UART.
Dans la section suivante, vous apprendrez comment connecter le TOF10120 au CrowPanel Display.
Connexion du TOF10120 au CrowPanel Display
Le CrowPanel Display dispose d’un port I2C et est livré avec un connecteur codé par couleur. La masse est noire, l’alimentation 3,3V est rouge, SCL est blanc (gris) et SDA est jaune. Connectez la masse à la broche 1, le 3,3V à la broche 2, SDA à la broche 5 et SCL à la broche 6 du TOF10120 comme montré ci-dessous :
Notez que les broches 3 et 4 (RxD, TxD) du TOF10120 ne sont pas connectées, car nous n’utilisons pas l’interface UART mais l’I2C.
L’image ci-dessous montre le câblage, certes un peu désordonné, du TOF10120 avec le CrowPanel en utilisant les connecteurs fournis et quelques câbles Dupont.
La bonne nouvelle est que vous n’avez pas besoin de breadboard ni de souder des fils.
Test du capteur TOF10120
Avant de réaliser quelque chose de complexe, il vaut mieux tester que le capteur est correctement connecté et fonctionne. Pour cela, il faut d’abord installer une bibliothèque pour lire les mesures de distance du capteur TOF10120.
Installer la bibliothèque TOF10120
Pour installer la bibliothèque TOF10120, allez dans le tof10120_arduino_lib repo here et cliquez sur le bouton vert « Code ». Puis cliquez sur « Download Zip » comme montré ci-dessous :
Dans l’IDE Arduino, créez le code de test suivant :
#include "TOF10120.h"
TOF10120 sensor = TOF10120();
void setup() {
Serial.begin(9600);
sensor.init();
}
void loop() {
Serial.print("distance:");
Serial.println(sensor.distance());
delay(100);
}
Ensuite, allez dans « Sketch » -> « Include Library » -> « Add .Zip Library.. » et sélectionnez le fichier « tof10120_arduino_lib-main.zip » que vous venez de télécharger :
Le code de test est très simple. Il inclut d’abord la bibliothèque TOF10120 et crée l’objet TOF10120 sensor . Dans la fonction setup() , le capteur est initialisé, et dans la fonction loop() , on appelle enfin sensor.distance() pour lire la distance mesurée par le capteur.
Exécuter le code de test pour TOF10120 sensor
Dans l’IDE Arduino, sélectionnez « ESP32 Dev Module » comme carte et assurez-vous que le CrowPanel Display est connecté au port USB et visible dans l’IDE Arduino.
Téléversez maintenant le code sur votre CrowPanel Display et vous devriez voir les valeurs de distance s’afficher dans le Moniteur Série. S’il n’y a pas d’objet devant le capteur, vous verrez une distance de 2000 mm affichée, et si le capteur n’est pas détecté, vous verrez un -1.
Si vous rencontrez des problèmes et que le capteur ne semble pas fonctionner, vérifiez que le câblage est correct et que les bonnes broches SDA et SCL sont utilisées. Vous pouvez aussi vérifier la diode laser du capteur en prenant une photo avec un appareil photo numérique (téléphone portable). Bien que la lumière IR soit invisible à l’œil humain, la caméra peut la voir. L’image ci-dessous montre le TOF10120 avec la diode IR clairement allumée :
Si le capteur TOF10120 fonctionne et que vous voyez les mesures de distance affichées, nous pouvons commencer la structure du projet pour le code principal.
Créer la structure du projet
Dans cette section, nous créons la structure du projet et la configuration pour le TFT_eSPI library nécessaire pour contrôler l’écran TFT.
Ouvrez votre IDE Arduino et créez un projet » parking_sensor_display » puis enregistrez-le (Enregistrer sous …). Cela créera un dossier » parking_sensor_display » contenant le fichier » parking_sensor_display.ino « . Dans ce dossier, créez un autre fichier nommé » tft_setup.h « . Votre dossier de projet devrait ressembler à ceci :
Et dans votre IDE Arduino, vous devriez maintenant avoir deux onglets nommés » parking_sensor_display.ino » et » tft_setup.h « .
Cliquez sur l’onglet » tft_setup.h » pour ouvrir le fichier et copiez-y le code suivant :
// tft_setup.h #define ILI9488_DRIVER #define TFT_HEIGHT 480 #define TFT_WIDTH 320 #define TFT_BACKLIGHT_ON HIGH #define TFT_BL 27 #define TFT_MISO 12 #define TFT_MOSI 13 #define TFT_SCLK 14 #define TFT_CS 15 #define TFT_DC 2 #define TFT_RST -1 #define TOUCH_CS 33 #define SPI_FREQUENCY 27000000 #define SPI_TOUCH_FREQUENCY 2500000 #define SPI_READ_FREQUENCY 16000000 #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:-. #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts
Ce code indique au TFT_eSPI library quel écran nous utilisons. Plus précisément, nous informons la bibliothèque des dimensions de l’écran (TFT_WIDTH, TFT_WIDTH), de son pilote d’affichage (ILI9488_DRIVER), des broches SPI utilisées pour le contrôler et des polices à charger. Sans ces réglages, vous ne pourrez rien afficher sur l’écran.
Pour plus d’informations détaillées, consultez le tutoriel CrowPanel 2.8″ ESP32 Display : Easy Setup Guide . Nous y expliquons comment configurer l’écran 2.8″. Mais les étapes et descriptions s’appliquent de la même manière à l’écran 3.5″. Seuls les réglages des dimensions et du pilote de l’écran diffèrent.
Calibration de l’écran tactile
Le CrowPanel 3.5″ Display est équipé d’un écran tactile résistif que vous devez calibrer avant de pouvoir l’utiliser avec la bibliothèque TFT_eSPI. Copiez le code ci-dessous dans le fichier » parking_sensor_display.ino « , compilez-le et téléversez-le sur le CrowPanel 3.5 » Display. Comme précédemment, utilisez le ESP32 Dev Module comme carte.
#include "tft_setup.h"
#include "TFT_eSPI.h"
TFT_eSPI tft = TFT_eSPI();
void setup() {
Serial.begin(9600);
tft.begin();
tft.setRotation(3);
}
void loop() {
uint16_t cal[5];
tft.fillScreen(TFT_BLACK);
tft.setCursor(20, 0);
tft.setTextFont(2);
tft.setTextSize(1);
tft.setTextColor(TFT_WHITE, TFT_BLACK);
tft.print("Touch corners ... ");
tft.calibrateTouch(cal, TFT_MAGENTA, TFT_BLACK, 15);
tft.println("done.");
Serial.printf("cal: {%d, %d, %d, %d, %d}\n",
cal[0], cal[1], cal[2], cal[3], cal[4]);
delay(10000);
}
Lorsque le code s’exécute, l’écran affiche une flèche et vous demande de toucher le coin vers lequel elle pointe. Cela se répète pour les trois autres coins. Utilisez le petit stylet jaune fourni avec l’écran pour cela et essayez de toucher les coins aussi précisément que possible.
À la fin du processus de calibration, le code affiche les 5 paramètres de calibration (coordonnées des coins et orientation de l’écran) dans le moniteur série. Vous devriez voir quelque chose comme ceci :
cal: { 273, 3534, 286, 3615, 4 }
Copiez ces paramètres quelque part, car vous en aurez besoin dans le code principal. La calibration se répète toutes les 10 secondes, vous pouvez donc faire plusieurs essais pour obtenir les paramètres les plus précis. Pour plus d’informations sur la calibration, consultez le tutoriel CrowPanel 2.8″ ESP32 Display : Easy Setup Guide .
Code pour le capteur de stationnement
Dans cette section, nous écrivons le code principal pour le système de capteur de stationnement utilisant l’écran CrowPanel ESP32 et le capteur de distance laser TOF10120. Le système mesure en continu la distance à un objet et l’affiche à l’écran, changeant de couleur selon la proximité de l’objet. Un bouton sur l’écran permet à l’utilisateur de définir un seuil de distance minimale.
La capture d’écran suivante montre les principaux éléments de l’interface utilisateur :
Jetez d’abord un coup d’œil au code complet, puis nous en détaillerons les parties :
#include "stdarg.h"
#include "tft_setup.h"
#include "TFT_eSPI.h"
#include "TOF10120.h"
TFT_eSPI tft = TFT_eSPI();
TOF10120 sensor = TOF10120();
uint16_t cal[5] = { 273, 3534, 286, 3615, 4 };
int minDist = 50;
int getDistance() {
return sensor.distance() / 10;
}
void drawString(int16_t x, int16_t y, uint8_t font, const char* format, ...) {
static char buf[64];
va_list args;
va_start(args, format);
vsnprintf(buf, 64, format, args);
tft.setTextDatum(MC_DATUM);
tft.drawString(buf, x, y, font);
}
void drawDistance() {
static char buf[32];
int dist = getDistance();
uint32_t color = TFT_GREEN;
if (dist < minDist * 1.5) color = TFT_YELLOW;
if (dist < minDist) color = TFT_RED;
tft.setTextColor(color, TFT_BLACK);
tft.setTextSize(3);
drawString(tft.width() / 2, 120, 7, " %d ", dist);
}
void drawButton() {
static bool oldTouch = true;
int cx = tft.width() / 2;
int bw = 140, bh = 50, bt = 3;
int x = cx - bw / 2, y = tft.height() - bh - 10;
uint16_t tx, ty;
bool isTouch = tft.getTouch(&tx, &ty);
isTouch = isTouch && (abs(tx - cx) < bw / 2) && (ty > y);
if (isTouch == oldTouch) return;
oldTouch = isTouch;
tft.fillSmoothRoundRect(x, y, bw, bh, 10, TFT_WHITE);
if (isTouch) {
tft.setTextColor(TFT_BLACK, TFT_WHITE, true);
minDist = getDistance();
} else {
tft.fillSmoothRoundRect(x + bt, y + bt, bw - 2 * bt, bh - 2 * bt, 10, TFT_BLACK);
tft.setTextColor(TFT_WHITE, TFT_BLACK, true);
}
drawString(cx, y + bh / 2, 1, "set");
tft.setTextColor(TFT_SILVER, TFT_BLACK, true);
drawString(cx, y - 30, 1, " %d ", minDist);
}
void setup(void) {
sensor.init();
tft.init();
tft.setRotation(3);
tft.fillScreen(TFT_BLACK);
}
void loop() {
drawDistance();
drawButton();
delay(100);
}
Décomposons le code en ses composants pour mieux le comprendre.
Inclusions de bibliothèques
Nous commençons par inclure les bibliothèques nécessaires à notre projet. Ces bibliothèques fournissent les fonctionnalités pour interagir avec l’écran et le capteur de distance.
#include "stdarg.h" #include "tft_setup.h" #include "TFT_eSPI.h" #include "TOF10120.h"
Initialisation des objets
Ensuite, nous créons des instances de l’écran et du capteur. L’objet TFT_eSPI tft est utilisé pour contrôler l’écran, tandis que l’objet TOF10120 sensor sert à interagir avec le capteur laser de distance.
TFT_eSPI tft = TFT_eSPI(); TOF10120 sensor = TOF10120();
Calibration et distance minimale
Nous définissons un tableau cal pour les valeurs de calibration et un entier minDist qui fixe le seuil de distance minimale pour le capteur. Ce seuil sera utilisé pour changer la couleur de la distance affichée selon la proximité d’un objet. Les valeurs de calibration proviennent du processus de calibration de l’écran tactile décrit précédemment.
uint16_t cal[5] = { 273, 3534, 286, 3615, 4 };
int minDist = 50;
Fonction de récupération de distance
La fonction getDistance() récupère la distance mesurée par le capteur et la convertit de millimètres en centimètres en la divisant par 10.
int getDistance() {
return sensor.distance() / 10;
}
Fonction d’affichage de texte
La fonction drawString() est un utilitaire pour afficher du texte formaté à l’écran. Elle utilise des arguments variables pour formater la chaîne, puis l’affiche centrée aux coordonnées spécifiées avec une police donnée.
void drawString(int16_t x, int16_t y, uint8_t font, const char* format, ...) {
static char buf[64];
va_list args;
va_start(args, format);
vsnprintf(buf, 64, format, args);
tft.setTextDatum(MC_DATUM);
tft.drawString(buf, x, y, font);
}
Fonction d’affichage de la distance
Dans la fonction drawDistance() , nous récupérons d’abord la distance actuelle avec getDistance() . Nous déterminons ensuite la couleur du texte selon la distance : vert pour une distance sûre, jaune pour la prudence, et rouge pour le danger.
void drawDistance() {
static char buf[32];
int dist = getDistance();
uint32_t color = TFT_GREEN;
if (dist < minDist * 1.5) color = TFT_YELLOW;
if (dist < minDist) color = TFT_RED;
tft.setTextColor(color, TFT_BLACK);
tft.setTextSize(3);
drawString(tft.width() / 2, 120, 7, " %d ", dist);
}
Enfin, nous affichons la distance en grand format à l’écran. Les trois captures d’écran suivantes montrent trois distances (en centimètres) dans les trois couleurs différentes :
Fonction d’affichage du bouton
La fonction drawButton() gère l’affichage d’un bouton à l’écran. Elle détecte les entrées tactiles et met à jour le seuil de distance minimale lorsque le bouton est pressé.
void drawButton() {
static bool oldTouch = true;
int cx = tft.width() / 2;
int bw = 140, bh = 50, bt = 3;
int x = cx - bw / 2, y = tft.height() - bh - 10;
uint16_t tx, ty;
bool isTouch = tft.getTouch(&tx, &ty);
isTouch = isTouch && (abs(tx - cx) < bw / 2) && (ty > y);
if (isTouch == oldTouch) return;
oldTouch = isTouch;
tft.fillSmoothRoundRect(x, y, bw, bh, 10, TFT_WHITE);
if (isTouch) {
tft.setTextColor(TFT_BLACK, TFT_WHITE, true);
minDist = getDistance();
} else {
tft.fillSmoothRoundRect(x + bt, y + bt, bw - 2 * bt, bh - 2 * bt, 10, TFT_BLACK);
tft.setTextColor(TFT_WHITE, TFT_BLACK, true);
}
drawString(cx, y + bh / 2, 1, "set");
tft.setTextColor(TFT_SILVER, TFT_BLACK, true);
drawString(cx, y - 30, 1, " %d ", minDist);
}
L’apparence du bouton change selon qu’il est pressé ou non. L’image ci-dessous montre le bouton « set » lorsqu’il n’est pas pressé :
Fonction setup
Dans la fonction setup() , nous initialisons le capteur et l’écran, réglons la rotation de l’écran et remplissons l’écran avec un fond noir.
void setup(void) {
sensor.init();
tft.init();
tft.setRotation(3);
tft.fillScreen(TFT_BLACK);
}
Fonction loop
Enfin, la fonction loop() appelle en continu drawDistance() et drawButton() pour mettre à jour l’affichage avec la distance actuelle et gérer les interactions du bouton. Un court délai est ajouté pour éviter des mises à jour excessives.
void loop() {
drawDistance();
drawButton();
delay(100);
}
Conclusions
Dans ce tutoriel, vous avez appris comment construire un capteur de stationnement avec le TOF10120 IR Laser Distance Sensor et un CrowPanel 3.5″ ESP32 Display .
De nombreuses extensions sont possibles pour ce projet. Par exemple, vous pourriez connecter une LED puissante au port GPIO et l’allumer lorsque la distance minimale est atteinte.
De même, vous pourriez utiliser la sortie haut-parleur du CrowPanel Display pour déclencher une alarme si un objet s’approche trop près. Il existe en fait un CrowPanel Pico 4.3″ Display basé sur RP2040 avec un buzzer intégré que vous pourriez utiliser, ou bien vous connectez un buzzer au port GPIO. Voir le Scribble on CrowPanel Pico 4.3″ Display pour plus de détails.
Enfin, au lieu du TOF10120, vous pourriez utiliser d’autres capteurs de distance infrarouges comme le très courant GP2Y0A710K0F ou le GP2Y0A21YK0F . Le capteur à ultrasons HC-SR04 est aussi souvent utilisé, il mesure la distance avec des ondes sonores. Cependant, les capteurs laser IR sont plus précis et ont une portée plus longue que les capteurs à ultrasons.
Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.
Bon bricolage ; )
