Système embarqué de détection d’obstacles avec Arduino UNO et capteur FC-51

Arduino 01-05-26

234 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 Arduino UNO

Présentation du projet

Ce projet a pour objectif de réaliser un système simple et efficace de détection d’obstacles en utilisant une carte Arduino UNO. Il permet de surveiller l’environnement proche grâce à un capteur infrarouge FC-51 et d’informer l’utilisateur en temps réel. Lorsqu’un objet est détecté, un message s’affiche sur un écran LCD I2C et une alerte sonore est déclenchée à l’aide d’un buzzer. Ce type de système est souvent utilisé dans des applications comme les robots mobiles, les systèmes de sécurité ou les dispositifs d’assistance automatique.

Le fonctionnement du projet repose sur le capteur FC-51 qui émet un faisceau infrarouge. Lorsque ce faisceau rencontre un obstacle, il est réfléchi vers le capteur, ce qui modifie l’état du signal de sortie. La carte Arduino UNO lit en permanence ce signal et détermine si un objet est présent ou non. En cas de détection, elle envoie une instruction pour afficher le message « Object detected ! » sur l’écran LCD I2C, tout en activant le buzzer pour produire un son d’alerte.

En revanche, lorsque aucun obstacle n’est détecté, le système continue de surveiller sans interruption. L’écran peut afficher un message indiquant l’absence d’objet, et le buzzer reste désactivé. Ainsi, ce projet illustre parfaitement l’interaction entre capteurs, traitement de l’information et actionneurs, tout en offrant une introduction pratique à la programmation et à l’électronique embarquée.

Matériel nécessaire

1- Arduino UNO

Arduino Uno

La carte Arduino UNO constitue le cœur du système. Elle joue le rôle de cerveau en exécutant le programme chargé dans sa mémoire. Elle lit les données provenant du capteur, traite ces informations, puis commande les autres composants comme l’afficheur LCD et le buzzer. Grâce à ses entrées et sorties numériques, elle permet de connecter facilement tous les éléments du montage.

2. Capteur FC-51

Le capteur FC-51 (infrarouge) est utilisé pour détecter les obstacles. Il émet un faisceau infrarouge et mesure la réflexion de ce signal lorsqu’un objet est présent devant lui. Lorsqu’un obstacle est détecté, le capteur change l’état de sa sortie (HIGH ou LOW), ce qui permet à l’Arduino de savoir qu’un objet est proche. Il est simple à utiliser et dispose généralement d’un potentiomètre pour régler la sensibilité.

3. Afficheur LCD I2C

L’afficheur LCD I2C permet d’afficher des messages pour informer l’utilisateur. Grâce au module I2C intégré, il utilise seulement deux fils de communication (SDA et SCL), ce qui simplifie le câblage. Il est utilisé dans ce projet pour afficher des messages comme « Object detected ! » ou « No object », rendant le système plus interactif et compréhensible.

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 Arduino UNO

Capteur FC-51	Arduino UNO
VCC	3V
GND	GND
OUT	D2

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

Afficheur LCD I2C	Arduino UNO
VCC	5V
GND	GND
SDA	A4
SCL	A5

3- Connexion du Buzzer à la carte Arduino UNO

Buzzer	Arduino UNO
Borne (+)	D3
Borne (-)	GND

Programmation de la carte Arduino

Ce programme permet de réaliser un système de détection d’obstacles en utilisant une carte Arduino UNO, un capteur infrarouge FC-51, un afficheur LCD I2C et un buzzer. Son rôle principal est de surveiller en continu la présence d’un objet devant le capteur et d’informer l’utilisateur à la fois visuellement et sonorement.

On commence par l’importation de cette bibliothèque:

LiquidCrystal_I2C → pour afficher les informations sur l’écran LCD I2C

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

//======================================
// Détection d'objet avec capteur FC-51
// Arduino UNO + Buzzer + LCD I2C 20x4
//======================================

#include <Wire.h>                // Bibliothèque pour communication I2C
#include <LiquidCrystal_I2C.h>  // Bibliothèque pour l'écran LCD I2C

// Création de l'objet LCD avec adresse I2C 0x27, 20 colonnes et 4 lignes
LiquidCrystal_I2C lcd(0x27, 20, 4);

// Définition des broches
const int sensorPin = 2;   // Broche connectée à la sortie du capteur FC-51
const int buzzerPin = 3;   // Broche connectée au buzzer

void setup()
{
  pinMode(sensorPin, INPUT);   // Configurer la broche du capteur comme entrée
  pinMode(buzzerPin, OUTPUT);  // Configurer la broche du buzzer comme sortie

  lcd.init();        // Initialiser l'écran LCD
  lcd.backlight();   // Allumer le rétroéclairage

  // Affichage du message de démarrage
  lcd.setCursor(0,0);                 // Position colonne 0, ligne 0
  lcd.print(" IR Object Sensor ");

  lcd.setCursor(0,1);                 // Position colonne 0, ligne 1
  lcd.print(" System Ready... ");

  delay(2000);   // Attendre 2 secondes
  lcd.clear();   // Effacer l'écran
}

void loop()
{
  // Lire l'état du capteur (HIGH ou LOW)
  int sensorState = digitalRead(sensorPin);

  // Si un objet est détecté (le FC-51 retourne souvent LOW)
  if(sensorState == LOW)
  {
    digitalWrite(buzzerPin, HIGH);  // Activer le buzzer

    // Afficher le message sur le LCD
    lcd.setCursor(0,0);
    lcd.print("Object Detected    ");

    lcd.setCursor(0,1);
    lcd.print("Buzzer ON          ");
  }
  else // Aucun objet détecté
  {
    digitalWrite(buzzerPin, LOW);   // Désactiver le buzzer

    // Afficher le message sur le LCD
    lcd.setCursor(0,0);
    lcd.print("No Object          ");

    lcd.setCursor(0,1);
    lcd.print("Buzzer OFF         ");
  }

  delay(200); // Petite pause pour stabiliser la lecture
}

//======================================

// Détection d'objet avec capteur FC-51

// Arduino UNO + Buzzer + LCD I2C 20x4

//======================================

#include <Wire.h> // Bibliothèque pour communication I2C

#include <LiquidCrystal_I2C.h> // Bibliothèque pour l'écran LCD I2C

// Création de l'objet LCD avec adresse I2C 0x27, 20 colonnes et 4 lignes

LiquidCrystal_I2C lcd(0x27, 20, 4);

// Définition des broches

const int sensorPin = 2; // Broche connectée à la sortie du capteur FC-51

const int buzzerPin = 3; // Broche connectée au buzzer

void setup()

{

pinMode(sensorPin, INPUT); // Configurer la broche du capteur comme entrée

pinMode(buzzerPin, OUTPUT); // Configurer la broche du buzzer comme sortie

lcd.init(); // Initialiser l'écran LCD

lcd.backlight(); // Allumer le rétroéclairage

// Affichage du message de démarrage

lcd.setCursor(0,0); // Position colonne 0, ligne 0

lcd.print(" IR Object Sensor ");

lcd.setCursor(0,1); // Position colonne 0, ligne 1

lcd.print(" System Ready... ");

delay(2000); // Attendre 2 secondes

lcd.clear(); // Effacer l'écran

}

void loop()

{

// Lire l'état du capteur (HIGH ou LOW)

int sensorState = digitalRead(sensorPin);

// Si un objet est détecté (le FC-51 retourne souvent LOW)

if(sensorState == LOW)

{

digitalWrite(buzzerPin, HIGH); // Activer le buzzer

// Afficher le message sur le LCD

lcd.setCursor(0,0);

lcd.print("Object Detected ");

lcd.setCursor(0,1);

lcd.print("Buzzer ON ");

}

else // Aucun objet détecté

{

digitalWrite(buzzerPin, LOW); // Désactiver le buzzer

// Afficher le message sur le LCD

lcd.setCursor(0,0);

lcd.print("No Object ");

lcd.setCursor(0,1);

lcd.print("Buzzer OFF ");

}

delay(200); // Petite pause pour stabiliser la lecture

}

Au démarrage, le programme initialise les composants. Il configure la broche du capteur comme entrée et celle du buzzer comme sortie. Ensuite, il initialise l’écran LCD I2C, active son rétroéclairage et affiche un message de bienvenue indiquant que le système est prêt à fonctionner. Après une courte pause de deux secondes, l’écran est effacé pour laisser place à l’affichage principal.

Dans la boucle principale, le programme lit en permanence l’état du capteur FC-51. Si le capteur détecte un objet (généralement lorsque le signal est à l’état LOW), l’Arduino active le buzzer pour produire un son et affiche sur l’écran le message « Object Detected » ainsi que l’état du buzzer. En revanche, si aucun objet n’est détecté, le buzzer est désactivé et l’écran affiche « No Object » accompagné de l’état « Buzzer OFF ».

Ainsi, ce programme met en œuvre un système simple d’interaction entre un capteur, une unité de traitement (Arduino) et des dispositifs de sortie (écran et buzzer). Il illustre le fonctionnement de base d’un système embarqué capable de détecter un événement et de réagir en conséquence.