Mesure intelligente du niveau d’eau avec ESP32 et capteur HC-SR04

ESP32 14-05-26

156 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 ESP32

Présentation du projet

Le projet de mesure intelligente du niveau d’eau consiste à surveiller en temps réel la hauteur de l’eau à l’aide d’une carte ESP32 et d’un capteur ultrasonique HC-SR04.

Ce système permet de mesurer automatiquement le niveau d’eau dans un réservoir, un verre ou une cuve sans contact direct avec l’eau.

L’objectif principal est de :

- mesurer la distance entre le capteur et la surface de l’eau

- calculer le niveau d’eau automatiquement

- afficher les informations en temps réel

- faciliter la surveillance du niveau d’eau de manière simple, rapide et intelligente

Fonctionnement du projet

Le capteur ultrasonique HC-SR04 est placé au-dessus du récipient contenant l’eau.

Il émet des ondes ultrasonores vers la surface de l’eau. Lorsque ces ondes rencontrent l’eau, elles sont réfléchies puis reviennent vers le capteur.

Ensuite, la carte ESP32 mesure le temps nécessaire au retour des ultrasons afin de calculer la distance entre le capteur et l’eau.

À partir de cette distance, le système détermine le niveau d’eau :

si la distance diminue, cela signifie que le niveau d’eau augmente

si la distance augmente, cela signifie que le niveau d’eau diminue

Les résultats peuvent ensuite être affichés sur un écran LCD/OLED ou envoyés vers une application mobile pour assurer une surveillance en temps réel.

Matériel nécessaire

1- Carte ESP32

La carte ESP32 est le composant principal du projet. Elle permet de recevoir les données du capteur ultrasonique, de calculer le niveau d’eau et de contrôler les différents périphériques du système.

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 ESP32

Capteur HC-SR04	Carte ESP32
VCC	5V
GND	GND
Trig	GPIO 18
Echo	GPIO 19

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

Programmation de la carte ESP32

Ce programme en MicroPython permet de réaliser un système intelligent de mesure du niveau d’eau à l’aide d’une carte ESP32, 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 de l'écran LCD I2C
# =========================================================

# Initialisation du bus I2C
# SCL connecté à GPIO22
# SDA connecté à GPIO21
# Fréquence I2C = 400 kHz
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)

# Initialisation de l'écran LCD I2C
# Adresse I2C = 0x27
# Écran de 2 lignes et 16 colonnes
lcd = I2cLcd(i2c, 0x27, 2, 16)

# =========================================================
# Configuration du capteur ultrasonique HC-SR04
# =========================================================

# Broche TRIG configurée en sortie
TRIG = Pin(18, Pin.OUT)

# Broche ECHO configurée en entrée
# Modifier la broche selon votre câblage
ECHO = Pin(19, Pin.IN)

# Hauteur maximale du récipient en cm
MAX_HEIGHT = 6.9

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

bar_chars = [
    bytearray([0,0,0,0,0,0,0,0]),                 # Barre vide
    bytearray([16,16,16,16,16,16,16,16]),        # 1/5 remplie
    bytearray([24,24,24,24,24,24,24,24]),        # 2/5 remplies
    bytearray([28,28,28,28,28,28,28,28]),        # 3/5 remplies
    bytearray([30,30,30,30,30,30,30,30]),        # 4/5 remplies
    bytearray([31,31,31,31,31,31,31,31])         # Barre totalement remplie
]

# 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
lcd.move_to(0, 0)
lcd.putstr("Niveau d'eau")

# =========================================================
# Fonction de mesure de distance
# =========================================================

def measure_distance():

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

    # Envoi d'une impulsion de 10 µs
    TRIG.on()
    sleep_us(10)
    TRIG.off()

    # Mesure de la durée du signal ECHO
    # Timeout = 30 ms
    duration = time_pulse_us(ECHO, 1, 30000)

    # Calcul de la distance en cm
    distance = (duration * 0.034) / 2

    return distance

# =========================================================
# Fonction de conversion de valeur
# =========================================================

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

    # Convertit une valeur d'un intervalle
    # vers un autre intervalle
    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 d'eau
    water_level = MAX_HEIGHT - (distance - 2.3)

    # Limitation de la valeur minimale
    if water_level < 0:
        water_level = 0

    # Limitation de la valeur maximale
    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
    # =====================================================

    lcd.move_to(0, 1)
    lcd.putstr(str(percent) + "%   ")

    # =====================================================
    # Création de la barre de progression
    # =====================================================

    # Nombre total de barres
    total_bars = 10

    # Conversion du pourcentage vers les barres
    filled = map_value(percent, 0, 100, 0, total_bars * 5)

    # Positionnement du curseur LCD
    lcd.move_to(5, 1)

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

        # 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

# 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 de l'écran LCD I2C

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

# Initialisation du bus I2C

# SCL connecté à GPIO22

# SDA connecté à GPIO21

# Fréquence I2C = 400 kHz

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

# Initialisation de l'écran LCD I2C

# Adresse I2C = 0x27

# Écran de 2 lignes et 16 colonnes

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

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

# Configuration du capteur ultrasonique HC-SR04

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

# Broche TRIG configurée en sortie

TRIG = Pin(18, Pin.OUT)

# Broche ECHO configurée en entrée

# Modifier la broche selon votre câblage

ECHO = Pin(19, Pin.IN)

# Hauteur maximale du récipient en cm

MAX_HEIGHT = 6.9

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

# Création des caractères personnalisés

# pour afficher une barre de progression

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

bar_chars = [

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

bytearray([16,16,16,16,16,16,16,16]), # 1/5 remplie

bytearray([24,24,24,24,24,24,24,24]), # 2/5 remplies

bytearray([28,28,28,28,28,28,28,28]), # 3/5 remplies

bytearray([30,30,30,30,30,30,30,30]), # 4/5 remplies

bytearray([31,31,31,31,31,31,31,31]) # Barre totalement remplie

]

# 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

lcd.move_to(0, 0)

lcd.putstr("Niveau d'eau")

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

# Fonction de mesure de distance

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

def measure_distance():

# Mise à 0 de TRIG

TRIG.off()

sleep_us(2)

# Envoi d'une impulsion de 10 µs

TRIG.on()

sleep_us(10)

TRIG.off()

# Mesure de la durée du signal ECHO

# Timeout = 30 ms

duration = time_pulse_us(ECHO, 1, 30000)

# Calcul de la distance en cm

distance = (duration * 0.034) / 2

return distance

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

# Fonction de conversion de valeur

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

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

# Convertit une valeur d'un intervalle

# vers un autre intervalle

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 d'eau

water_level = MAX_HEIGHT - (distance - 2.3)

# Limitation de la valeur minimale

if water_level < 0:

water_level = 0

# Limitation de la valeur maximale

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

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

lcd.move_to(0, 1)

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

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

# Création de la barre de progression

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

# Nombre total de barres

total_bars = 10

# Conversion du pourcentage vers les barres

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

# Positionnement du curseur LCD

lcd.move_to(5, 1)

# Affichage des barres

for i in range(total_bars):

# 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 ESP32. 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.