Utilisation du capteur FC-51 pour la détection d’obstacles avec ESP32

ESP32 01-05-26

184 0

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

3- Schéma de câblage du système de détection d'obstacles

4- Programmation de la carte ESP32

Présentation du projet

L’objectif de ce projet est de concevoir un système capable de détecter la présence d’un obstacle et d’alerter l’utilisateur en temps réel. Il utilise une ESP32 comme unité de contrôle, un capteur FC-51 pour la détection, un afficheur LCD I2C pour l’affichage, et un buzzer électronique pour l’alerte sonore.

Ce type de système est très utilisé dans des applications comme :

- les robots mobiles (éviter les collisions),

- les systèmes de sécurité,

- les dispositifs d’aide au stationnement.

Fonctionnement du système

Le fonctionnement repose sur la détection infrarouge du capteur FC-51. Ce capteur émet un faisceau infrarouge et mesure la réflexion de ce signal. Lorsqu’un objet se trouve devant le capteur, le signal est réfléchi et détecté.

La ESP32 lit en permanence l’état du capteur. Si aucun obstacle n’est détecté, le système reste en mode attente. Dès qu’un obstacle est présent à une distance proche, le capteur envoie un signal numérique à la carte.

À ce moment-là, la carte traite l’information et déclenche deux actions simultanées. D’abord, elle affiche un message sur l’afficheur LCD I2C pour indiquer la présence de l’obstacle. Ensuite, elle active le buzzer électronique qui émet un signal sonore pour alerter l’utilisateur.

Lorsque l’obstacle disparaît, le capteur ne détecte plus de réflexion, et le système revient automatiquement à son état initial. L’affichage peut être mis à jour (par exemple “aucun obstacle”) et le buzzer s’arrête.

Matériel nécessaire

1- Carte ESP32

La carte ESP32 est un microcontrôleur puissant qui assure le traitement des données. Il lit les informations provenant du capteur, prend des décisions en fonction de ces données, puis contrôle les autres éléments comme l’afficheur et le buzzer. Grâce à ses nombreuses broches et à sa facilité de programmation, il est très adapté aux projets embarqués.

2. Capteur FC-51

Le capteur FC-51 est un capteur infrarouge utilisé pour détecter la présence d’un obstacle. Il fonctionne en émettant un signal infrarouge et en détectant sa réflexion sur un objet proche. Lorsqu’un obstacle est présent, le capteur envoie un signal numérique à l’ESP32. Il possède généralement un potentiomètre permettant d’ajuster la sensibilité et la distance de détection.

3. Afficheur LCD I2C

L’afficheur LCD I2C est utilisé pour afficher les informations du système. Il affiche les messages tels que « obstacle détecté » ou « aucun obstacle ».

4. Buzzer :

Le buzzer électronique est un composant qui produit un son lorsqu’il est activé. Dans ce projet, il sert d’alarme sonore pour avertir immédiatement l’utilisateur lorsqu’un obstacle est détecté. Il peut fonctionner de manière continue ou par impulsions selon le programme.

5. Câbles de Connexion (Jumper Wires)

Fils de connexion

Les fils de connexion permettent de relier les différents composants entre eux.

6- Breadboard (Plaque d'essai) :

plaque d'essai

Une breadboard est utile pour créer un circuit temporaire et connecter facilement les composants entre eux.

Schéma de câblage du système de détection d'obstacles

1- Connexion du capteur FC-51 à la carte ESP32

Capteur FC-51	Carte ESP32
VCC	3V
GND	GND
OUT	GPIO 14

2- Connexion de l’afficheur LCD I2C à la carte ESP32

Afficheur LCD I2C	Carte ESP32
VCC	5V
GND	GND
SDA	GPIO 21
SCL	GPIO 22

3- Connexion du Buzzer à la carte ESP32

Buzzer	Carte ESP32
Borne (+)	GPIO 23
Borne (-)	GND

Programmation de la carte ESP32

Ce programme réalise un système simple de détection d’obstacles à l’aide d’une carte ESP32, d’un capteur infrarouge FC-51, d’un buzzer et d’un afficheur LCD I2C 20x4. Son rôle principal est de surveiller en permanence la présence d’un objet devant le capteur et d’informer l’utilisateur à la fois par un signal sonore et par un message affiché à l’écran.

On commence par l’importation de ces bibliothèques:

i2c_lcd et lcd_api → pour afficher les informations sur l’écran LCD I2C

Voici le code en Micropython qui implémente le fonctionnement du système :

# ===============================
# Détection d'obstacles avec capteur IR FC-51
# ESP32 + Buzzer + LCD I2C 20x4
# ===============================

from machine import Pin, I2C
from time import sleep
from i2c_lcd import I2cLcd

# Adresse I2C de l'écran LCD (souvent 0x27 ou 0x3F)
I2C_ADDR = 0x27

# Initialisation de la communication I2C pour l'ESP32
# scl = broche horloge (GPIO22), sda = broche données (GPIO21)
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)

# Initialisation de l'écran LCD (4 lignes, 20 colonnes)
lcd = I2cLcd(i2c, I2C_ADDR, 4, 20)

# Configuration du capteur infrarouge FC-51
# Connecté à la broche GPIO14 en entrée
sensor = Pin(14, Pin.IN)

# Configuration du buzzer
# Connecté à la broche GPIO23 en sortie
buzzer = Pin(23, Pin.OUT)

# Affichage du message de démarrage
lcd.clear()                 # Effacer l'écran
lcd.move_to(0,0)            # Placer le curseur ligne 1, colonne 1
lcd.putstr(" IR Object Sensor ")
lcd.move_to(0,1)            # Placer le curseur ligne 2
lcd.putstr("System Ready...")
sleep(2)                    # Attendre 2 secondes

lcd.clear()                 # Effacer l'écran après démarrage

# Boucle principale (fonctionne en continu)
while True:

    # Lecture de l'état du capteur
    # Le capteur FC-51 renvoie 0 lorsqu'un objet est détecté
    if sensor.value() == 0:   # Objet détecté
        
        buzzer.value(1)       # Activer le buzzer (alarme sonore)

        lcd.move_to(0,0)
        lcd.putstr("Object Detected!  ")  # Afficher le message de détection

    else:   # Aucun objet détecté
        
        buzzer.value(0)       # Désactiver le buzzer

        lcd.move_to(0,0)
        lcd.putstr("No Object         ")  # Afficher le message d'absence

    sleep(0.2)   # Petite pause pour stabiliser la lecture

# ===============================

# Détection d'obstacles avec capteur IR FC-51

# ESP32 + Buzzer + LCD I2C 20x4

# ===============================

from machine import Pin, I2C

from time import sleep

from i2c_lcd import I2cLcd

# Adresse I2C de l'écran LCD (souvent 0x27 ou 0x3F)

I2C_ADDR = 0x27

# Initialisation de la communication I2C pour l'ESP32

# scl = broche horloge (GPIO22), sda = broche données (GPIO21)

i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)

# Initialisation de l'écran LCD (4 lignes, 20 colonnes)

lcd = I2cLcd(i2c, I2C_ADDR, 4, 20)

# Configuration du capteur infrarouge FC-51

# Connecté à la broche GPIO14 en entrée

sensor = Pin(14, Pin.IN)

# Configuration du buzzer

# Connecté à la broche GPIO23 en sortie

buzzer = Pin(23, Pin.OUT)

# Affichage du message de démarrage

lcd.clear() # Effacer l'écran

lcd.move_to(0,0) # Placer le curseur ligne 1, colonne 1

lcd.putstr(" IR Object Sensor ")

lcd.move_to(0,1) # Placer le curseur ligne 2

lcd.putstr("System Ready...")

sleep(2) # Attendre 2 secondes

lcd.clear() # Effacer l'écran après démarrage

# Boucle principale (fonctionne en continu)

while True:

# Lecture de l'état du capteur

# Le capteur FC-51 renvoie 0 lorsqu'un objet est détecté

if sensor.value() == 0: # Objet détecté

buzzer.value(1) # Activer le buzzer (alarme sonore)

lcd.move_to(0,0)

lcd.putstr("Object Detected! ") # Afficher le message de détection

else: # Aucun objet détecté

buzzer.value(0) # Désactiver le buzzer

lcd.move_to(0,0)

lcd.putstr("No Object ") # Afficher le message d'absence

sleep(0.2) # Petite pause pour stabiliser la lecture

Au démarrage, le programme initialise les différents composants. Il configure la communication I2C nécessaire pour piloter l’écran LCD, puis prépare le capteur infrarouge en entrée et le buzzer en sortie. Un message de bienvenue s’affiche sur l’écran (“IR Object Sensor” puis “System Ready…”) pendant quelques secondes, indiquant que le système est prêt à fonctionner.

Ensuite, le programme entre dans une boucle infinie dans laquelle il lit continuellement l’état du capteur. Lorsque le capteur détecte un objet, il envoie une valeur logique basse (0). Dans ce cas, le buzzer est activé pour produire un signal sonore, et le message “Object Detected!” s’affiche sur la première ligne de l’écran LCD. Cela permet d’alerter immédiatement l’utilisateur de la présence d’un obstacle.

En revanche, si aucun objet n’est détecté, le capteur renvoie une valeur logique haute (1). Le buzzer est alors désactivé et l’écran affiche le message “No Object”, indiquant que la zone surveillée est libre. Une courte pause de 0,2 seconde est ajoutée à chaque cycle pour assurer une lecture stable et éviter des changements trop rapides.