Projet de mesure du niveau d’eau avec Micro:bit et capteur HC-SR04

Micro:bit 19-05-26

30 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 Micro:bit

Présentation du projet

L’objectif de ce projet est de réaliser un système intelligent capable de mesurer et d’afficher le niveau d’eau dans un verre en utilisant la carte Micro:bit, le capteur ultrason HC-SR04 et un afficheur LCD I2C.

Ce système permet de surveiller le niveau d’eau en temps réel grâce à la mesure de la distance entre le capteur et la surface de l’eau. Les résultats sont ensuite affichés sur l’écran LCD sous forme de valeurs ou de barres graphiques afin de faciliter la lecture du niveau d’eau.

Fonctionnement du projet

Lorsque de l’eau est versée dans un verre, le capteur ultrason HC-SR04 mesure la distance entre le capteur et la surface de l’eau à l’aide des ultrasons.

La carte Micro:bit traite les données mesurées puis calcule le niveau d’eau correspondant. Ensuite, les résultats sont affichés sur l’écran LCD I2C sous forme numérique ou graphique pour assurer une surveillance en temps réel.

Lorsque le niveau d’eau augmente, le nombre de barres affichées sur l’écran LCD augmente également. Inversement, lorsque le niveau d’eau diminue, le nombre de barres affichées diminue aussi.

Ce projet peut être utilisé pour découvrir les principes de la mesure ultrasonique, de l’affichage LCD et de la programmation des systèmes embarqués avec la carte Micro:bit.

Matériel nécessaire

1- Carte Micro:bit

Micro:bit board

La carte Micro:bit est une carte électronique programmable utilisée pour réaliser des projets éducatifs et interactifs. Elle permet de traiter les données provenant du capteur ultrason et de contrôler l’affichage des résultats sur l’écran LCD I2C.

2- Carte d'Extension GPIO pour Micro:bit

The GPIO expansion card for the Micro:bit card

La carte d’extension facilite la connexion des différents composants électroniques à la carte Micro:bit. Elle permet d’accéder facilement aux broches d’entrée et de sortie, d’alimenter les modules électroniques et de simplifier le câblage du projet.

3. 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.

4. 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.

5. Câbles de Connexion (Jumper Wires)

Fils de connexion

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

6. 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 Micro:bit

Capteur HC-SR04	Carte Micro:bit
VCC	5V
GND	GND
Trig	P1
Echo	P2

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

Afficheur LCD I2C	Carte ESP32
VCC	5V
GND	GND
SDA	P20
SCL	P19

Programmation de la carte Micro:bit

Ce programme permet de réaliser un système intelligent de mesure et d’affichage du niveau d’eau à l’aide de la carte Micro:bit, du capteur Capteur HC-SR04 et d’un Afficheur LCD I2C.

Le programme mesure en temps réel la distance entre le capteur ultrason et la surface de l’eau dans un verre. Ensuite, la carte Micro:bit traite les données reçues afin de calculer le niveau d’eau sous forme de pourcentage.

Les résultats sont affichés sur l’écran LCD I2C sous forme numérique ainsi que sous forme de barres graphiques permettant de visualiser facilement le niveau d’eau.

Lorsque le niveau d’eau augmente, le pourcentage et le nombre de barres affichées augmentent également. Inversement, lorsque le niveau d’eau diminue, les barres graphiques diminuent aussi.

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

# Importation des bibliothèques nécessaires
from microbit import *
import utime

# Adresse I2C de l'afficheur LCD
LCD_ADDR = 0x27

# ==================================================
# FONCTIONS DE GESTION DE L'AFFICHEUR LCD I2C
# ==================================================

# Fonction d'envoi de données ou commandes au LCD
def lcd_write(cmd, mode=0):

    # Partie haute de l’octet
    high = mode | (cmd & 0xF0) | 0x08

    # Partie basse de l’octet
    low  = mode | ((cmd << 4) & 0xF0) | 0x08

    # Envoi des données avec impulsion Enable
    i2c.write(LCD_ADDR, bytes([high | 0x04]))
    i2c.write(LCD_ADDR, bytes([high & ~0x04]))
    i2c.write(LCD_ADDR, bytes([low | 0x04]))
    i2c.write(LCD_ADDR, bytes([low & ~0x04]))

# Fonction d’envoi d’une commande au LCD
def lcd_cmd(cmd):
    lcd_write(cmd, 0)

# Fonction d’envoi d’un caractère au LCD
def lcd_data(data):
    lcd_write(data, 1)

# Fonction d’initialisation du LCD
def lcd_init():

    # Petite temporisation au démarrage
    sleep(50)

    # Séquence d'initialisation LCD 4 bits
    lcd_cmd(0x33)
    lcd_cmd(0x32)

    # Mode 4 bits, 2 lignes
    lcd_cmd(0x28)

    # Affichage activé
    lcd_cmd(0x0C)

    # Déplacement automatique du curseur
    lcd_cmd(0x06)

    # Effacement de l’écran
    lcd_cmd(0x01)

    sleep(5)

# Fonction d’effacement de l’écran LCD
def lcd_clear():
    lcd_cmd(0x01)
    sleep(5)

# Fonction d’affichage d’un texte
def lcd_putstr(text):
    for c in text:
        lcd_data(ord(c))

# Fonction de positionnement du curseur
def lcd_goto(col, row):

    # Calcul de l’adresse mémoire du curseur
    addr = col + (0x40 * row)

    # Envoi de la position au LCD
    lcd_cmd(0x80 | addr)

# ==================================================
# CRÉATION DES CARACTÈRES PERSONNALISÉS
# BARRES GRAPHIQUES (0 → 5 niveaux)
# ==================================================

# Définition des motifs graphiques
bar_chars = [

    # Barre vide
    [0,0,0,0,0,0,0,0],

    # Niveau 1
    [16,16,16,16,16,16,16,16],

    # Niveau 2
    [24,24,24,24,24,24,24,24],

    # Niveau 3
    [28,28,28,28,28,28,28,28],

    # Niveau 4
    [30,30,30,30,30,30,30,30],

    # Barre pleine
    [31,31,31,31,31,31,31,31]
]

# Fonction de création des caractères personnalisés
def lcd_create_char(location, pattern):

    # Limitation de l’emplacement mémoire
    location &= 0x7

    # Sélection de l’adresse CGRAM
    lcd_cmd(0x40 | (location << 3))

    # Envoi du motif graphique
    for i in range(8):
        lcd_data(pattern[i])

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

# Broche Trigger connectée à P1
TRIG = pin1

# Broche Echo connectée à P2
ECHO = pin2

# Hauteur maximale du verre d’eau
MAX_HEIGHT = 6.5

# Fonction de mesure de distance
def measure_distance():

    # Mise à zéro du Trigger
    TRIG.write_digital(0)
    utime.sleep_us(2)

    # Envoi d’une impulsion ultrasonique
    TRIG.write_digital(1)
    utime.sleep_us(10)
    TRIG.write_digital(0)

    # Attente du début de l’écho
    while ECHO.read_digital() == 0:
        start = utime.ticks_us()

    # Attente de la fin de l’écho
    while ECHO.read_digital() == 1:
        end = utime.ticks_us()

    # Calcul de la durée de l’écho
    duration = utime.ticks_diff(end, start)

    # Conversion en distance (cm)
    return (duration * 0.034) / 2

# ==================================================
# INITIALISATION
# ==================================================

# Initialisation du LCD
lcd_init()

# Chargement des 6 caractères personnalisés
for i in range(6):
    lcd_create_char(i, bar_chars[i])

# Affichage du titre sur la première ligne
lcd_goto(0, 0)
lcd_putstr("Water level")

# ==================================================
# FONCTION MAP
# ==================================================

# Fonction de conversion d’une valeur
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 la surface de l’eau
    distance = measure_distance()

    # Calcul du niveau d’eau
    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
    # ==================================================

    lcd_goto(0, 1)

    # Affichage du pourcentage du niveau d’eau
    lcd_putstr(str(percent) + "%   ")

    # ==================================================
    # AFFICHAGE DE LA BARRE GRAPHIQUE
    # ==================================================

    # Nombre total de barres
    total_bars = 10

    # Calcul du niveau graphique total
    filled = map_value(percent, 0, 100, 0, total_bars * 5)

    # Positionnement du curseur
    lcd_goto(5, 1)

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

        # Niveau de remplissage de chaque barre
        level = filled - (i * 5)

        # Barre complètement remplie
        if level >= 5:
            lcd_data(5)

        # Barre partiellement remplie
        elif level > 0:
            lcd_data(level)

        # Barre vide
        else:
            lcd_data(0)

    # Actualisation toutes les 500 ms
    sleep(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

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

# Importation des bibliothèques nécessaires

from microbit import *

import utime

# Adresse I2C de l'afficheur LCD

LCD_ADDR = 0x27

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

# FONCTIONS DE GESTION DE L'AFFICHEUR LCD I2C

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

# Fonction d'envoi de données ou commandes au LCD

def lcd_write(cmd, mode=0):

# Partie haute de l’octet

high = mode | (cmd & 0xF0) | 0x08

# Partie basse de l’octet

low = mode | ((cmd << 4) & 0xF0) | 0x08

# Envoi des données avec impulsion Enable

i2c.write(LCD_ADDR, bytes([high | 0x04]))

i2c.write(LCD_ADDR, bytes([high & ~0x04]))

i2c.write(LCD_ADDR, bytes([low | 0x04]))

i2c.write(LCD_ADDR, bytes([low & ~0x04]))

# Fonction d’envoi d’une commande au LCD

def lcd_cmd(cmd):

lcd_write(cmd, 0)

# Fonction d’envoi d’un caractère au LCD

def lcd_data(data):

lcd_write(data, 1)

# Fonction d’initialisation du LCD

def lcd_init():

# Petite temporisation au démarrage

sleep(50)

# Séquence d'initialisation LCD 4 bits

lcd_cmd(0x33)

lcd_cmd(0x32)

# Mode 4 bits, 2 lignes

lcd_cmd(0x28)

# Affichage activé

lcd_cmd(0x0C)

# Déplacement automatique du curseur

lcd_cmd(0x06)

# Effacement de l’écran

lcd_cmd(0x01)

sleep(5)

# Fonction d’effacement de l’écran LCD

def lcd_clear():

lcd_cmd(0x01)

sleep(5)

# Fonction d’affichage d’un texte

def lcd_putstr(text):

for c in text:

lcd_data(ord(c))

# Fonction de positionnement du curseur

def lcd_goto(col, row):

# Calcul de l’adresse mémoire du curseur

addr = col + (0x40 * row)

# Envoi de la position au LCD

lcd_cmd(0x80 | addr)

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

# CRÉATION DES CARACTÈRES PERSONNALISÉS

# BARRES GRAPHIQUES (0 → 5 niveaux)

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

# Définition des motifs graphiques

bar_chars = [

# Barre vide

[0,0,0,0,0,0,0,0],

# Niveau 1

[16,16,16,16,16,16,16,16],

# Niveau 2

[24,24,24,24,24,24,24,24],

# Niveau 3

[28,28,28,28,28,28,28,28],

# Niveau 4

[30,30,30,30,30,30,30,30],

# Barre pleine

[31,31,31,31,31,31,31,31]

]

# Fonction de création des caractères personnalisés

def lcd_create_char(location, pattern):

# Limitation de l’emplacement mémoire

location &= 0x7

# Sélection de l’adresse CGRAM

lcd_cmd(0x40 | (location << 3))

# Envoi du motif graphique

for i in range(8):

lcd_data(pattern[i])

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

# CONFIGURATION DU CAPTEUR HC-SR04

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

# Broche Trigger connectée à P1

TRIG = pin1

# Broche Echo connectée à P2

ECHO = pin2

# Hauteur maximale du verre d’eau

MAX_HEIGHT = 6.5

# Fonction de mesure de distance

def measure_distance():

# Mise à zéro du Trigger

TRIG.write_digital(0)

utime.sleep_us(2)

# Envoi d’une impulsion ultrasonique

TRIG.write_digital(1)

utime.sleep_us(10)

TRIG.write_digital(0)

# Attente du début de l’écho

while ECHO.read_digital() == 0:

start = utime.ticks_us()

# Attente de la fin de l’écho

while ECHO.read_digital() == 1:

end = utime.ticks_us()

# Calcul de la durée de l’écho

duration = utime.ticks_diff(end, start)

# Conversion en distance (cm)

return (duration * 0.034) / 2

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

# INITIALISATION

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

# Initialisation du LCD

lcd_init()

# Chargement des 6 caractères personnalisés

for i in range(6):

lcd_create_char(i, bar_chars[i])

# Affichage du titre sur la première ligne

lcd_goto(0, 0)

lcd_putstr("Water level")

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

# FONCTION MAP

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

# Fonction de conversion d’une valeur

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 la surface de l’eau

distance = measure_distance()

# Calcul du niveau d’eau

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

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

lcd_goto(0, 1)

# Affichage du pourcentage du niveau d’eau

lcd_putstr(str(percent) + "% ")

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

# AFFICHAGE DE LA BARRE GRAPHIQUE

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

# Nombre total de barres

total_bars = 10

# Calcul du niveau graphique total

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

# Positionnement du curseur

lcd_goto(5, 1)

# Affichage des barres graphiques

for i in range(total_bars):

# Niveau de remplissage de chaque barre

level = filled - (i * 5)

# Barre complètement remplie

if level >= 5:

lcd_data(5)

# Barre partiellement remplie

elif level > 0:

lcd_data(level)

# Barre vide

else:

lcd_data(0)

# Actualisation toutes les 500 ms

sleep(500)

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Projet de mesure du niveau d’eau avec Micro:bit et capteur HC-SR04

Micro:bit 19-05-26

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

ESP32 14-05-26

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

Arduino 08-05-26

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

ESP8266 06-05-26

Utilisation du capteur FC-51 pour la détection d’obstacles avec ESP32

ESP32 01-05-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 12865vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 12277vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 10491vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino 10060vues

Allumer une LED par la carte ESP32

ESP32 9901vues

Construction des robots

Tutoriels plus commentés

Construire un GPS commandé par Arduino

Arduino 74 commentaires

Premiers pas avec Micro:bit et MakeCode

Micro:bit 51 commentaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 32 commentaires

Présentation du module capteur de lumière à LDR

Composants 22 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino 17 commentaires

Projet de mesure du niveau d’eau avec Micro:bit et capteur HC-SR04

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 Micro:bit

Présentation du projet

Matériel nécessaire

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

Programmation de la carte Micro:bit

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles