Mesure en temps réel du niveau d’eau avec Arduino et HC-SR04

Arduino 08-05-26

1341 1

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

3- Schéma de câblage du système

4- Programmation de la carte Arduino UNO

Présentation du projet

Ce projet a pour objectif de mesurer le niveau d’eau en temps réel à l’aide d’une carte Arduino, d’un capteur ultrasonique HC-SR04, d’un verre contenant de l’eau et d’un afficheur LCD I2C.

Le système permet de surveiller la hauteur de l’eau sans contact direct avec le liquide, puis d’afficher instantanément les informations mesurées sur l’écran LCD.

Ce projet peut être utilisé pour comprendre le fonctionnement des capteurs à ultrasons dans les systèmes de surveillance et d’automatisation.

Fonctionnement du projet

Le capteur ultrasonique HC-SR04 est placé au-dessus du verre afin d’envoyer des ondes ultrasonores vers la surface de l’eau. Lorsque les ultrasons rencontrent l’eau, ils sont réfléchis vers le capteur.

La carte Arduino calcule ensuite la distance entre le capteur et la surface de l’eau à partir du temps de retour des ondes ultrasonores.

Après le calcul de cette distance, l’Arduino détermine le niveau d’eau présent dans le verre.

Ensuite, l’afficheur LCD I2C affiche des barres représentant visuellement le niveau d’eau : plus le verre est rempli, plus le nombre de barres affichées augmente.

Lorsque le niveau d’eau diminue, le nombre de barres affichées diminue également. Ainsi, le système permet une surveillance simple et rapide du niveau d’eau en temps réel.

Matériel nécessaire

1- Arduino UNO

Arduino Uno

La carte Arduino UNO est une carte électronique programmable basée sur le microcontrôleur ATmega328P. Elle permet de contrôler et de gérer tous les composants du projet. Dans ce système, elle lit les données envoyées par le capteur HC-SR04, calcule le niveau d’eau et affiche les résultats sur l’écran LCD I2C.

2. Capteur ultrasonique HC-SR04

HC-SR04

Le HC-SR04 est un capteur à ultrasons utilisé pour mesurer des distances sans contact physique. Il fonctionne en envoyant des ondes ultrasonores puis en recevant leur écho après réflexion sur un objet ou une surface. Dans ce projet, il mesure la distance entre le capteur et la surface de l’eau afin de déterminer le niveau d’eau dans le verre.

3. Afficheur LCD I2C

L’afficheur LCD I2C permet d’afficher les informations du projet de manière claire et instantanée. Dans ce système, il affiche le niveau d’eau détecté par le capteur HC-SR04 sous forme de barres graphiques qui augmentent ou diminuent selon la quantité d’eau présente dans le verre.

4. Câbles de Connexion (Jumper Wires)

Fils de connexion

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

Schéma de câblage du système du système

1- Connexion du capteur HC-SR04 à la carte Arduino UNO

Capteur HC-SR04	Arduino UNO
VCC	5V
GND	GND
Trig	D2
Echo	D3

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

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

Programmation de la carte Arduino

Ce programme Arduino permet de mesurer le niveau d’eau dans un verre ou un réservoir à l’aide du capteur ultrasonique HC-SR04 et d’afficher le résultat en temps réel sur un afficheur LCD I2C. La carte Arduino envoie des impulsions ultrasonores grâce au capteur HC-SR04 afin de mesurer la distance entre le capteur et la surface de l’eau. Ensuite, le programme calcule le niveau d’eau en fonction de la hauteur maximale du récipient.

Le pourcentage du niveau d’eau est affiché sur l’écran LCD, accompagné d’une barre de progression graphique composée de caractères personnalisés. Plus le niveau d’eau augmente, plus les barres affichées sur l’écran se remplissent. Ce système permet donc de surveiller visuellement et facilement la quantité d’eau présente dans le récipient en temps réel.

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 :

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

// Initialisation de l'écran LCD I2C
// Adresse I2C = 0x27, écran 16 colonnes et 2 lignes
LiquidCrystal_I2C lcd(0x27, 16, 2);

// ==============================
// Configuration du capteur HC-SR04
// ==============================
#define TRIG_PIN 2   // Broche TRIG connectée à la broche 2
#define ECHO_PIN 3   // Broche ECHO connectée à la broche 3

// Hauteur maximale du réservoir ou du verre (en cm)
#define MAX_HEIGHT 8.5

// ==============================
// Création des caractères personnalisés
// pour afficher une barre de progression
// ==============================

// Barre vide
byte bar0[8] = {0,0,0,0,0,0,0,0};

// Barre remplie à 20%
byte bar1[8] = {16,16,16,16,16,16,16,16};

// Barre remplie à 40%
byte bar2[8] = {24,24,24,24,24,24,24,24};

// Barre remplie à 60%
byte bar3[8] = {28,28,28,28,28,28,28,28};

// Barre remplie à 80%
byte bar4[8] = {30,30,30,30,30,30,30,30};

// Barre remplie à 100%
byte bar5[8] = {31,31,31,31,31,31,31,31};

// Variables pour la mesure
long duration;     // Durée du retour des ultrasons
float distance;    // Distance mesurée

void setup() {

  // Définition des broches du capteur
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);

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

  // Activation du rétroéclairage
  lcd.backlight();

  // ==============================
  // Création des caractères personnalisés
  // ==============================
  lcd.createChar(0, bar0);
  lcd.createChar(1, bar1);
  lcd.createChar(2, bar2);
  lcd.createChar(3, bar3);
  lcd.createChar(4, bar4);
  lcd.createChar(5, bar5);

  // Affichage du titre du projet
  lcd.setCursor(0,0);
  lcd.print("Niveau d'eau");
}

void loop() {

  // ==============================
  // Mesure de la distance avec HC-SR04
  // ==============================

  // Envoi d'une impulsion ultrasonique
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);

  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);

  digitalWrite(TRIG_PIN, LOW);

  // Lecture du temps de retour des ultrasons
  duration = pulseIn(ECHO_PIN, HIGH);

  // Calcul de la distance en cm
  distance = duration * 0.034 / 2;

  // Calcul du niveau d'eau
  // 2.3 représente un ajustement/calibrage du capteur
  float waterLevel = MAX_HEIGHT - (distance - 2.3);

  // Empêcher les valeurs négatives
  if (waterLevel < 0)
    waterLevel = 0;

  // Empêcher les valeurs supérieures à la hauteur maximale
  if (waterLevel > MAX_HEIGHT)
    waterLevel = MAX_HEIGHT;

  // ==============================
  // Conversion du niveau d'eau en pourcentage
  // ==============================
  int percent = (waterLevel / MAX_HEIGHT) * 100;

  // ==============================
  // Affichage du pourcentage sur LCD
  // ==============================
  lcd.setCursor(0,1);

  // Création de la chaîne à afficher
  String value_display = String(percent) + "%  ";

  // Affichage du pourcentage
  lcd.print(value_display);

  // ==============================
  // Affichage de la barre de progression
  // ==============================

  // Nombre total de cases de la barre
  int totalBars = 10;

  // Conversion du pourcentage en nombre de blocs
  int filled = map(percent, 0, 100, 0, totalBars * 5);

  // Position du curseur après le pourcentage
  lcd.setCursor(5,1);

  // Boucle pour dessiner les 10 cases
  for (int i = 0; i < totalBars; i++) {

    // Calcul du niveau de remplissage de chaque case
    int barLevel = filled - (i * 5);

    // Affichage du caractère correspondant
    if (barLevel >= 5)
      lcd.write(5);   // Barre complètement remplie

    else if (barLevel > 0)
      lcd.write(barLevel); // Barre partiellement remplie

    else
      lcd.write(0);   // Barre vide
  }

  // Pause avant la prochaine mesure
  delay(500);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

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

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

// Initialisation de l'écran LCD I2C

// Adresse I2C = 0x27, écran 16 colonnes et 2 lignes

LiquidCrystal_I2C lcd(0x27, 16, 2);

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

// Configuration du capteur HC-SR04

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

#define TRIG_PIN 2 // Broche TRIG connectée à la broche 2

#define ECHO_PIN 3 // Broche ECHO connectée à la broche 3

// Hauteur maximale du réservoir ou du verre (en cm)

#define MAX_HEIGHT 8.5

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

// Création des caractères personnalisés

// pour afficher une barre de progression

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

// Barre vide

byte bar0[8] = {0,0,0,0,0,0,0,0};

// Barre remplie à 20%

byte bar1[8] = {16,16,16,16,16,16,16,16};

// Barre remplie à 40%

byte bar2[8] = {24,24,24,24,24,24,24,24};

// Barre remplie à 60%

byte bar3[8] = {28,28,28,28,28,28,28,28};

// Barre remplie à 80%

byte bar4[8] = {30,30,30,30,30,30,30,30};

// Barre remplie à 100%

byte bar5[8] = {31,31,31,31,31,31,31,31};

// Variables pour la mesure

long duration; // Durée du retour des ultrasons

float distance; // Distance mesurée

void setup() {

// Définition des broches du capteur

pinMode(TRIG_PIN, OUTPUT);

pinMode(ECHO_PIN, INPUT);

// Initialisation de l'écran LCD

lcd.init();

// Activation du rétroéclairage

lcd.backlight();

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

// Création des caractères personnalisés

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

lcd.createChar(0, bar0);

lcd.createChar(1, bar1);

lcd.createChar(2, bar2);

lcd.createChar(3, bar3);

lcd.createChar(4, bar4);

lcd.createChar(5, bar5);

// Affichage du titre du projet

lcd.setCursor(0,0);

lcd.print("Niveau d'eau");

}

void loop() {

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

// Mesure de la distance avec HC-SR04

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

// Envoi d'une impulsion ultrasonique

digitalWrite(TRIG_PIN, LOW);

delayMicroseconds(2);

digitalWrite(TRIG_PIN, HIGH);

delayMicroseconds(10);

digitalWrite(TRIG_PIN, LOW);

// Lecture du temps de retour des ultrasons

duration = pulseIn(ECHO_PIN, HIGH);

// Calcul de la distance en cm

distance = duration * 0.034 / 2;

// Calcul du niveau d'eau

// 2.3 représente un ajustement/calibrage du capteur

float waterLevel = MAX_HEIGHT - (distance - 2.3);

// Empêcher les valeurs négatives

if (waterLevel < 0)

waterLevel = 0;

// Empêcher les valeurs supérieures à la hauteur maximale

if (waterLevel > MAX_HEIGHT)

waterLevel = MAX_HEIGHT;

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

// Conversion du niveau d'eau en pourcentage

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

int percent = (waterLevel / MAX_HEIGHT) * 100;

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

// Affichage du pourcentage sur LCD

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

lcd.setCursor(0,1);

// Création de la chaîne à afficher

String value_display = String(percent) + "% ";

// Affichage du pourcentage

lcd.print(value_display);

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

// Affichage de la barre de progression

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

// Nombre total de cases de la barre

int totalBars = 10;

// Conversion du pourcentage en nombre de blocs

int filled = map(percent, 0, 100, 0, totalBars * 5);

// Position du curseur après le pourcentage

lcd.setCursor(5,1);

// Boucle pour dessiner les 10 cases

for (int i = 0; i < totalBars; i++) {

// Calcul du niveau de remplissage de chaque case

int barLevel = filled - (i * 5);

// Affichage du caractère correspondant

if (barLevel >= 5)

lcd.write(5); // Barre complètement remplie

else if (barLevel > 0)

lcd.write(barLevel); // Barre partiellement remplie

else

lcd.write(0); // Barre vide

}

// Pause avant la prochaine mesure

delay(500);

}

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.