Utilisation du capteur infrarouge FC-51 avec l’ESP8266 NodeMCU

ESP8266 06-05-26

257 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 ESP8266

Présentation du projet

Ce projet a pour objectif de concevoir un système simple de détection d’obstacles basé sur la carte ESP8266 NodeMCU. Il utilise un capteur infrarouge FC-51 pour détecter la présence d’un objet, un afficheur LCD I2C pour afficher l’état du système, et un buzzer pour fournir une alerte sonore. L’ensemble permet de réaliser un dispositif interactif capable d’informer l’utilisateur en temps réel de la présence ou de l’absence d’un obstacle, ce qui peut être utile dans des applications comme les robots mobiles, les systèmes de sécurité ou les dispositifs d’aide au stationnement.

Fonctionnement du projet :

Le fonctionnement repose sur l’émission et la réception d’un rayon infrarouge par le capteur FC-51. Lorsque aucun obstacle n’est présent, le capteur ne reçoit pas de signal réfléchi et envoie un état logique à la carte ESP8266. En revanche, lorsqu’un objet se trouve devant le capteur, le rayon infrarouge est réfléchi vers le récepteur, ce qui modifie l’état de sortie du capteur.

La carte ESP8266 lit en continu ce signal :

- Sans obstacle : L’écran LCD affiche un message indiquant qu’aucun objet n’est détecté, et le buzzer reste désactivé.

- Avec obstacle : L’écran LCD affiche un message d’alerte (par exemple “Obstacle détecté”), et le buzzer émet un signal sonore pour prévenir l’utilisateur.

Grâce à la communication I2C, l’afficheur LCD utilise seulement deux broches, ce qui simplifie le câblage. Le buzzer, quant à lui, est commandé directement par une sortie numérique de l’ESP8266.

Matériel nécessaire

1- Carte ESP8266 NodeMCU

La carte ESP8266 NodeMCU est le cerveau du système. Elle exécute le programme, lit les données du capteur FC-51 et commande les autres composants.

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’a carte ESP8266 NodeMCU. 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 ESP8266 NodeMCU

Capteur FC-51	ESP8266 NodeMCU
VCC	3V
GND	GND
OUT	D5

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

Afficheur LCD I2C	ESP8266 NodeMCU
VCC	5V
GND	GND
SDA	D2
SCL	D1

3- Connexion du Buzzer à la carte ESP8266 NodeMCU

Buzzer	ESP8266 NodeMCU
Borne (+)	D0
Borne (-)	GND

Programmation de la carte ESP8266

Ce programme réalise un système simple de détection d’obstacles à l’aide d’une carte ESP8266 NodeMCU, 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'objet avec capteur IR FC-51
# ESP8266 NodeMCU + LCD I2C 20x4 + Buzzer
# ==========================================

from machine import Pin, I2C   # Import des modules pour gérer les broches et le bus I2C
from time import sleep         # Import de la fonction pause
from i2c_lcd import I2cLcd     # Bibliothèque pour contrôler l'écran LCD I2C

# Adresse I2C de l'écran LCD (à vérifier avec un scanner I2C si besoin)
I2C_ADDR = 0x27

# Configuration du bus I2C pour ESP8266
# GPIO5 = SCL, GPIO4 = SDA
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=400000)

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

# Configuration du capteur infrarouge FC-51
# GPIO14 configuré en entrée (lecture du signal du capteur)
sensor = Pin(14, Pin.IN)

# Configuration du buzzer
# GPIO16 configuré en sortie
buzzer = Pin(16, Pin.OUT)
buzzer.value(0)   # Éteindre le buzzer au démarrage

# -------------------------------
# Affichage du message de démarrage
# -------------------------------
lcd.clear()               # Effacer l'écran
lcd.move_to(0,0)          # Position curseur ligne 1, colonne 1
lcd.putstr("IR Object Detector")  # Message principal

lcd.move_to(0,1)          # Ligne 2
lcd.putstr("System Ready...")     # Message de préparation

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
    # FC-51 retourne généralement 0 lorsqu'un obstacle est détecté
    if sensor.value() == 0:   # Objet détecté

        buzzer.value(1)       # Activer le buzzer (son ON)

        lcd.move_to(0,0)
        lcd.putstr("Object Detected     ")  # Affichage détection

        lcd.move_to(0,1)
        lcd.putstr("Buzzer ON           ")  # Indiquer buzzer actif

    else:   # Aucun objet détecté

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

        lcd.move_to(0,0)
        lcd.putstr("No Object           ")  # Affichage aucun objet

        lcd.move_to(0,1)
        lcd.putstr("Buzzer OFF          ")  # Indiquer buzzer arrêté

    sleep(0.2)  # Petite pause pour stabiliser la lecture (200 ms)

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

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

# ESP8266 NodeMCU + LCD I2C 20x4 + Buzzer

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

from machine import Pin, I2C # Import des modules pour gérer les broches et le bus I2C

from time import sleep # Import de la fonction pause

from i2c_lcd import I2cLcd # Bibliothèque pour contrôler l'écran LCD I2C

# Adresse I2C de l'écran LCD (à vérifier avec un scanner I2C si besoin)

I2C_ADDR = 0x27

# Configuration du bus I2C pour ESP8266

# GPIO5 = SCL, GPIO4 = SDA

i2c = I2C(scl=Pin(5), sda=Pin(4), freq=400000)

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

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

# Configuration du capteur infrarouge FC-51

# GPIO14 configuré en entrée (lecture du signal du capteur)

sensor = Pin(14, Pin.IN)

# Configuration du buzzer

# GPIO16 configuré en sortie

buzzer = Pin(16, Pin.OUT)

buzzer.value(0) # Éteindre le buzzer au démarrage

# -------------------------------

# Affichage du message de démarrage

# -------------------------------

lcd.clear() # Effacer l'écran

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

lcd.putstr("IR Object Detector") # Message principal

lcd.move_to(0,1) # Ligne 2

lcd.putstr("System Ready...") # Message de préparation

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

# FC-51 retourne généralement 0 lorsqu'un obstacle est détecté

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

buzzer.value(1) # Activer le buzzer (son ON)

lcd.move_to(0,0)

lcd.putstr("Object Detected ") # Affichage détection

lcd.move_to(0,1)

lcd.putstr("Buzzer ON ") # Indiquer buzzer actif

else: # Aucun objet détecté

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

lcd.move_to(0,0)

lcd.putstr("No Object ") # Affichage aucun objet

lcd.move_to(0,1)

lcd.putstr("Buzzer OFF ") # Indiquer buzzer arrêté

sleep(0.2) # Petite pause pour stabiliser la lecture (200 ms)

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.