Système de mesure du niveau d’eau avec ESP8266 NodeMCU et HC-SR04

ESP8266 23-05-26

13 0

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

Présentation du projet

Le système de mesure du niveau d’eau avec la carte ESP8266 NodeMCU et le capteur ultrasonique HC-SR04 a pour objectif de mesurer automatiquement la hauteur de l’eau dans un récipient ou un réservoir et d’afficher les résultats en temps réel.

Ce système permet :

- de surveiller le niveau d’eau de manière intelligente et automatique ;

- d’éviter le débordement ou le manque d’eau ;

- d’obtenir des mesures précises sans contact direct avec l’eau ;

- d’afficher les informations sur un écran LCD ou une application mobile ;

- d’utiliser la connectivité Wi-Fi de l’ESP8266 pour des applications IoT.

Fonctionnement du système

Le fonctionnement du système repose sur l’utilisation du capteur ultrasonique HC-SR04 et de la carte ESP8266 NodeMCU.

1- Le capteur HC-SR04 émet des ondes ultrasoniques vers la surface de l’eau.

2- Ces ondes se réfléchissent sur l’eau et reviennent vers le capteur.

3- Le capteur mesure le temps nécessaire pour le retour de l’écho.

4- L’ESP8266 NodeMCU calcule la distance entre le capteur et la surface de l’eau à partir du temps mesuré.

5- En utilisant la hauteur totale du réservoir, le système détermine le niveau d’eau présent dans le récipient.

6- Les résultats sont ensuite affichés sous forme de valeurs numériques ou de barres graphiques sur un afficheur LCD.

Grâce au module Wi-Fi intégré de l’ESP8266 NodeMCU, les données peuvent également être envoyées vers une application mobile ou une plateforme IoT pour une surveillance à distance en temps réel.

Matériel nécessaire

1- Carte ESP8266 NodeMCU

La carte ESP8266 NodeMCU est un microcontrôleur doté d’un module Wi-Fi intégré. Elle permet de contrôler l’ensemble du système, de traiter les données du capteur HC-SR04 et d’afficher les résultats.

2. Capteur ultrasonique HC-SR04

HC-SR04

Le capteur HC-SR04 sert à mesurer la distance entre le capteur et la surface de l’eau. Il fonctionne en envoyant des ultrasons puis en recevant leur écho après réflexion sur l’eau. La distance mesurée permet ensuite de déterminer le niveau d’eau dans le récipient.

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.

5. Plaque d'essai

La plaque d’essai (breadboard) permet de réaliser des montages électroniques sans soudure.

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

1- Connexion du capteur HC-SR04 à la carte ESP8266 NodeMCU

Capteur HC-SR04	ESP8266 NodeMCU
VCC	5V
GND	GND
Trig	D14
Echo	D12

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

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

Programmation de la carte ESP8266 NodeMCU

Ce programme en MicroPython permet de réaliser un système intelligent de mesure du niveau d’eau à l’aide d’une carte ESP8266 NodeMCU, d’un capteur ultrasonique HC-SR04 et d’un afficheur LCD I2C.

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 :

# =========================================================
# Importation des bibliothèques nécessaires
# =========================================================
from machine import Pin, I2C, time_pulse_us
from time import sleep, sleep_us
from i2c_lcd import I2cLcd

# =========================================================
# CONFIGURATION I2C ET AFFICHEUR LCD
# ESP8266 NodeMCU :
# SCL = D1 (GPIO5)
# SDA = D2 (GPIO4)
# =========================================================

# Initialisation du bus I2C
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=100000)

# Initialisation de l'afficheur LCD I2C
# Adresse I2C = 0x27
# LCD : 2 lignes x 16 colonnes
lcd = I2cLcd(i2c, 0x27, 2, 16)

# =========================================================
# CONFIGURATION DU CAPTEUR ULTRASONIQUE HC-SR04
# =========================================================

# Broche TRIG connectée à D5 (GPIO14)
# Sert à envoyer les ultrasons
TRIG = Pin(14, Pin.OUT)

# Broche ECHO connectée à D6 (GPIO12)
# Sert à recevoir l’écho des ultrasons
ECHO = Pin(12, Pin.IN)

# Hauteur maximale du réservoir en cm
MAX_HEIGHT = 6.5

# =========================================================
# CREATION DES BARRES GRAPHIQUES PERSONNALISÉES
# =========================================================

# Chaque tableau représente une barre graphique
# de remplissage pour l'affichage LCD
bar_chars = [

    # Barre vide
    bytearray([0,0,0,0,0,0,0,0]),

    # Barre remplie à 20%
    bytearray([16,16,16,16,16,16,16,16]),

    # Barre remplie à 40%
    bytearray([24,24,24,24,24,24,24,24]),

    # Barre remplie à 60%
    bytearray([28,28,28,28,28,28,28,28]),

    # Barre remplie à 80%
    bytearray([30,30,30,30,30,30,30,30]),

    # Barre complètement remplie
    bytearray([31,31,31,31,31,31,31,31])
]

# Enregistrement des caractères personnalisés dans le LCD
for i in range(6):
    lcd.custom_char(i, bar_chars[i])

# Affichage du titre sur la première ligne du LCD
lcd.move_to(0, 0)
lcd.putstr("Niveau d'eau  ")

# =========================================================
# FONCTION DE MESURE DE DISTANCE
# =========================================================
def measure_distance():

    # Mise à LOW de TRIG
    TRIG.off()
    sleep_us(2)

    # Envoi d'une impulsion de 10 microsecondes
    # pour déclencher les ultrasons
    TRIG.on()
    sleep_us(10)
    TRIG.off()

    # Mesure de la durée de l'écho reçu
    duration = time_pulse_us(ECHO, 1, 30000)

    # Vérification si aucune mesure n'est reçue
    if duration < 0:
        return 0

    # Calcul de la distance en cm
    # Vitesse du son = 0.034 cm/us
    distance = (duration * 0.034) / 2

    return distance

# =========================================================
# FONCTION MAP
# Convertit une valeur d'une plage vers une autre
# =========================================================
def map_value(x, in_min, in_max, out_min, out_max):

    return int(
        (x - in_min) *
        (out_max - out_min) /
        (in_max - in_min) +
        out_min
    )

# =========================================================
# BOUCLE PRINCIPALE
# =========================================================
while True:

    # Mesure de la distance entre le capteur et l’eau
    distance = measure_distance()

    # Calcul du niveau réel d’eau
    # 2.3 cm représente la distance du capteur
    # au bord supérieur du réservoir
    water_level = MAX_HEIGHT - (distance - 2.3)

    # Limitation du niveau minimum
    if water_level < 0:
        water_level = 0

    # Limitation du niveau maximum
    if water_level > MAX_HEIGHT:
        water_level = MAX_HEIGHT

    # Conversion du niveau d’eau en pourcentage
    percent = int((water_level / MAX_HEIGHT) * 100)

    # Affichage du pourcentage sur le LCD
    lcd.move_to(0, 1)
    lcd.putstr(str(percent) + "%   ")

    # Nombre total de barres graphiques
    total_bars = 10

    # Conversion du pourcentage en niveau graphique
    filled = map_value(percent, 0, 100, 0, total_bars * 5)

    # Positionnement du curseur après le pourcentage
    lcd.move_to(5, 1)

    # Affichage des barres graphiques
    for i in range(total_bars):

        # Calcul du niveau de remplissage de chaque barre
        bar_level = filled - (i * 5)

        # Barre totalement remplie
        if bar_level >= 5:
            lcd.putchar(chr(5))

        # Barre partiellement remplie
        elif bar_level > 0:
            lcd.putchar(chr(bar_level))

        # Barre vide
        else:
            lcd.putchar(chr(0))

    # Petite pause avant la prochaine mesure
    sleep(0.5)

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

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

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

# Importation des bibliothèques nécessaires

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

from machine import Pin, I2C, time_pulse_us

from time import sleep, sleep_us

from i2c_lcd import I2cLcd

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

# CONFIGURATION I2C ET AFFICHEUR LCD

# ESP8266 NodeMCU :

# SCL = D1 (GPIO5)

# SDA = D2 (GPIO4)

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

# Initialisation du bus I2C

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

# Initialisation de l'afficheur LCD I2C

# Adresse I2C = 0x27

# LCD : 2 lignes x 16 colonnes

lcd = I2cLcd(i2c, 0x27, 2, 16)

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

# CONFIGURATION DU CAPTEUR ULTRASONIQUE HC-SR04

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

# Broche TRIG connectée à D5 (GPIO14)

# Sert à envoyer les ultrasons

TRIG = Pin(14, Pin.OUT)

# Broche ECHO connectée à D6 (GPIO12)

# Sert à recevoir l’écho des ultrasons

ECHO = Pin(12, Pin.IN)

# Hauteur maximale du réservoir en cm

MAX_HEIGHT = 6.5

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

# CREATION DES BARRES GRAPHIQUES PERSONNALISÉES

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

# Chaque tableau représente une barre graphique

# de remplissage pour l'affichage LCD

bar_chars = [

# Barre vide

bytearray([0,0,0,0,0,0,0,0]),

# Barre remplie à 20%

bytearray([16,16,16,16,16,16,16,16]),

# Barre remplie à 40%

bytearray([24,24,24,24,24,24,24,24]),

# Barre remplie à 60%

bytearray([28,28,28,28,28,28,28,28]),

# Barre remplie à 80%

bytearray([30,30,30,30,30,30,30,30]),

# Barre complètement remplie

bytearray([31,31,31,31,31,31,31,31])

]

# Enregistrement des caractères personnalisés dans le LCD

for i in range(6):

lcd.custom_char(i, bar_chars[i])

# Affichage du titre sur la première ligne du LCD

lcd.move_to(0, 0)

lcd.putstr("Niveau d'eau ")

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

# FONCTION DE MESURE DE DISTANCE

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

def measure_distance():

# Mise à LOW de TRIG

TRIG.off()

sleep_us(2)

# Envoi d'une impulsion de 10 microsecondes

# pour déclencher les ultrasons

TRIG.on()

sleep_us(10)

TRIG.off()

# Mesure de la durée de l'écho reçu

duration = time_pulse_us(ECHO, 1, 30000)

# Vérification si aucune mesure n'est reçue

if duration < 0:

return 0

# Calcul de la distance en cm

# Vitesse du son = 0.034 cm/us

distance = (duration * 0.034) / 2

return distance

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

# FONCTION MAP

# Convertit une valeur d'une plage vers une autre

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

def map_value(x, in_min, in_max, out_min, out_max):

return int(

(x - in_min) *

(out_max - out_min) /

(in_max - in_min) +

out_min

)

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

# BOUCLE PRINCIPALE

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

while True:

# Mesure de la distance entre le capteur et l’eau

distance = measure_distance()

# Calcul du niveau réel d’eau

# 2.3 cm représente la distance du capteur

# au bord supérieur du réservoir

water_level = MAX_HEIGHT - (distance - 2.3)

# Limitation du niveau minimum

if water_level < 0:

water_level = 0

# Limitation du niveau maximum

if water_level > MAX_HEIGHT:

water_level = MAX_HEIGHT

# Conversion du niveau d’eau en pourcentage

percent = int((water_level / MAX_HEIGHT) * 100)

# Affichage du pourcentage sur le LCD

lcd.move_to(0, 1)

lcd.putstr(str(percent) + "% ")

# Nombre total de barres graphiques

total_bars = 10

# Conversion du pourcentage en niveau graphique

filled = map_value(percent, 0, 100, 0, total_bars * 5)

# Positionnement du curseur après le pourcentage

lcd.move_to(5, 1)

# Affichage des barres graphiques

for i in range(total_bars):

# Calcul du niveau de remplissage de chaque barre

bar_level = filled - (i * 5)

# Barre totalement remplie

if bar_level >= 5:

lcd.putchar(chr(5))

# Barre partiellement remplie

elif bar_level > 0:

lcd.putchar(chr(bar_level))

# Barre vide

else:

lcd.putchar(chr(0))

# Petite pause avant la prochaine mesure

sleep(0.5)

Explication du programme :

Au démarrage, le programme initialise la communication I2C afin de connecter l’écran LCD à la carte ESP826 NodeMCU. Ensuite, il configure les broches du capteur HC-SR04 la broche TRIG pour envoyer les ultrasons etla broche ECHO pour recevoir les ultrasons réfléchis par la surface de l’eau.

Le programme crée également plusieurs caractères personnalisés sur l’écran LCD afin d’afficher une barre de progression représentant visuellement le niveau d’eau.

Dans la boucle principale, le capteur ultrasonique envoie des ondes ultrasonores vers l’eau. Lorsque les ultrasons rencontrent la surface de l’eau, ils sont réfléchis puis reviennent vers le capteur. Le programme mesure alors le temps de retour des ultrasons pour calculer la distance entre le capteur et l’eau.

À partir de cette distance, le programme calcule automatiquement le niveau d’eau ainsi que son pourcentage de remplissage.

Ensuite, le pourcentage du niveau d’eau est affiché sur l’écran LCD sous forme des barres de progression dynamique qui montrent visuellement le niveau d’eau dans le récipient.

Enfin, le système répète continuellement les mesures toutes les 0,5 seconde afin d’assurer une surveillance du niveau d’eau en temps réel.