Mesurer le niveau d’eau à distance en utilisant ESP32

ESP32 26-11-24

24 0

Plan de tutoriel

1- Objectif de mesure d'eau

2- Comment la carte ESP32 mesure le niveau d'eau et l'affiche dans le Smartphone ?

3- Matériel nécessaire

4- Montage du système de mesure d'eau

5- Programmation de la carte ESP32

6- Programmation d'une application mobile avec App Inventor

Objectif de mesure d'eau

Un objectif de mesure d'eau consiste à surveiller et contrôler la quantité d'eau utilisée, consommée ou disponible dans un contexte spécifique (comme l'agriculture, l'industrie, ou les ménages) dans le but de mieux gérer cette ressource. Voici quelques objectifs principaux pour mesurer l'eau :

Suivi de la consommation : Connaître la quantité d'eau consommée pour mieux gérer les ressources et réduire les gaspillages.

Gestion de l'irrigation : En agriculture, mesurer l'eau permet d'ajuster l'irrigation en fonction des besoins réels des cultures, ce qui peut améliorer les rendements tout en économisant l'eau.

Prévention des pénuries : Surveiller les réserves d'eau, comme celles des barrages ou des nappes phréatiques, pour anticiper les périodes de sécheresse et mieux les gérer.

Surveillance de la qualité : Dans certaines applications, il est aussi utile de mesurer des paramètres de qualité (comme la présence de contaminants) pour s'assurer que l'eau est potable ou adaptée à son usage prévu.

Optimisation des coûts : En contrôlant l'utilisation de l'eau, il est possible de réduire les coûts associés à l'approvisionnement et au traitement de l'eau.

Ces objectifs de mesure sont souvent réalisés grâce à des compteurs, des capteurs, ou des systèmes connectés, qui transmettent les données en temps réel pour permettre une gestion réactive et efficiente.

Comment la carte ESP32 mesure le niveau d'eau et l'affiche dans le Smartphone ?

Pour mesurer le niveau d’eau et afficher les données sur un smartphone en utilisant une carteESP32, des fils de connexion, une bouteille d’eau, et l’outil MIT App Inventor, voici une description complète :

Fonctionnement global

1- Détection du niveau d’eau :
La carte ESP32 utilise des fils de connexion insérés dans la bouteille pour détecter le niveau d’eau à différentes hauteurs.

2- Transmission Bluetooth :
Les informations sur le niveau d’eau sont envoyées sans fil depuis la carte ESP32 vers le smartphone via le module HC-06.

3- Affichage sur smartphone :
Une application créée avec MIT App Inventor reçoit les données et les affiche sous forme de texte ou graphiquement.

Étapes détaillées du système

a) ESP32 : Détection du niveau d’eau

1- Connexion des fils dans la bouteille :
Les fils sont insérés à différents niveaux dans la bouteille. Chaque fil correspond à un niveau précis (ex. 25%, 50%, 75%, 100%).

2- Lecture des niveaux :
Les fils sont connectés aux broches numériques/analogiques de la carte ESP32. Lorsque l’eau atteint un fil, la carte ESP32 détecte un signal, car l’eau agit comme un conducteur.

3- Traitement des données :
La carte ESP32 analyse les données pour calculer le pourcentage du niveau d’eau.

b) Communication via HC-06

1- Configuration du module Bluetooth HC-06 :
Le module Bluetooth est relié à la carte ESP32 et configuré pour transmettre les données. La communication est établie via la liaison série (TX, RX).

2- Envoi des données :
La carte ESP32 envoie les niveaux d’eau détectés au module HC-06, qui les transmet au smartphone.

c) Affichage sur le smartphone avec MIT App Inventor

1- Création de l’application :
Une application est développée dans MIT App Inventor pour recevoir et afficher les données envoyées par la carte ESP32.

2- Affichage des données :
Les données sont affichées sous forme de texte (ex. "Niveau d'eau : 75%") ou de graphiques (barres ou jauges).

Matériel nécessaire

Carte ESP32 :

ESP32 card

pour contrôler et traiter les données.

Fils conducteurs :

Fils de connexion

placés dans la bouteille à différentes hauteurs pour mesurer le niveau d'eau.

Bouteille (ou un récipient similaire) :

pour contenir l'eau.

Résistances :

quatre résistances

pour limiter le courant et protéger les entrées analogiques.

Smartphone :

pour afficher les résultats.

Plaque de prototypage (breadboard)

plaque d'essai

Une plaque de prototypage permet d’organiser les connexions et de tester le montage sans avoir besoin de soudures.

Montage du système de mesure d'eau

1- On perce 5 trous dans la bouteille. Puis on fixe un fil de connexion dans chaque trous.

2- On branche les 4 resistances à la broche GND de la carte ESP32.

3-Ensuite on connecte:

le plus bas fil de connexion à la broche 3.3V de la carte ESP32

le 2ème fil de connexion à la broche D33 de la carte ESP32

le 3ème fil de connexion à la broche D32 de la carte ESP32

le 4ème fil de connexion à la broche D35 de la carte ESP32

le 5ème fil de connexion à la broche D33 de la carte ESP32

Programmation de la carte ESP32

Voici un exemple de code Micropython pour détecter le niveau d'eau et envoyer les données via Bluetooth :

Il faut importer ces bibliothèques :ble_uart_peripheral.py et ble_advertising.py.

il faut utiliser le Firmware suivant : esp32-20210902-v1.17.bin.

from esp_ble_uart import *
import time
from machine import Pin, ADC
from machine import freq
#freq(160000000)

level_1 = ADC(Pin(33))
level_1.atten(ADC.ATTN_11DB) 

level_2 = ADC(Pin(32))
level_2.atten(ADC.ATTN_11DB) 

level_3 = ADC(Pin(35))
level_3.atten(ADC.ATTN_11DB) 

level_4 = ADC(Pin(34))
level_4.atten(ADC.ATTN_11DB) 

nom = 'ESP32-ble-uart-gcworks'
UUID_UART = '6E400001-B5A3-F393-E0A9-E50E24DCCA9E'
UUID_TX = '6E400003-B5A3-F393-E0A9-E50E24DCCA9E'
UUID_RX = '6E400002-B5A3-F393-E0A9-E50E24DCCA9E'
val_rx = "12"

uart = Bleuart(nom, UUID_UART, UUID_TX, UUID_RX)
uart.close()

def rcp_rx():
    global val_rx
    if uart.any():
        while uart.any():
          val_rx = uart.read().decode().strip()
          print('sur rx: ', val_rx)              

def env_tx(val_tx):
    uart.write(str(val_tx) + '\n')
    print("tx", val_tx)

send_1=0
send_2=0
send_3=0
send_4=0
while True:
    #uart.irq(handler=rcp_rx)
    level_1_value = level_1.read()
    print("niveau 1",level_1_value)
    level_2_value = level_2.read()
    print("niveau 2",level_2_value)
    level_3_value = level_3.read()
    print("niveau 3",level_3_value)
    level_4_value = level_4.read()
    print("niveau 4",level_4_value)
    if (level_1.read()==0)  and (level_2.read()==0) and (level_3.read()==0) and (level_4.read()==0):
      env_tx("0")       # envoyer le niveau 0 d'eau au Smartphone 
      send_1=0
    if (level_1.read()!=0) and (level_2.read()==0) and (level_3.read()==0) and (level_4.read()==0) and send_1==0:
      env_tx("25")       # envoyer le niveau 1 d'eau au Smartphone
      send_1=1
      send_2=0  
    if (level_1.read()!=0) and (level_2.read()!=0) and (level_3.read()==0) and (level_4.read()==0) and send_2==0:
      env_tx("50")       # envoyer le niveau 2 d'eau au Smartphone
      send_1=0
      send_2=1
      send_3=0
    if (level_1.read()!=0) and (level_2.read()!=0) and (level_3.read()!=0) and (level_4.read()==0) and send_3==0:
      env_tx("75")       # envoyer le niveau 3 d'eau au Smartphone
      send_2=0
      send_3=1
      send_4=0
    if (level_1.read()!=0) and (level_2.read()!=0) and (level_3.read()!=0) and (level_4.read()!=0) and send_4==0:
      env_tx("100")       # envoyer le niveau 4 d'eau au Smartphone
      send_3=0
      send_4=1

    time.sleep_ms(500)

from esp_ble_uart import *

import time

from machine import Pin, ADC

from machine import freq

#freq(160000000)

level_1 = ADC(Pin(33))

level_1.atten(ADC.ATTN_11DB)

level_2 = ADC(Pin(32))

level_2.atten(ADC.ATTN_11DB)

level_3 = ADC(Pin(35))

level_3.atten(ADC.ATTN_11DB)

level_4 = ADC(Pin(34))

level_4.atten(ADC.ATTN_11DB)

nom = 'ESP32-ble-uart-gcworks'

UUID_UART = '6E400001-B5A3-F393-E0A9-E50E24DCCA9E'

UUID_TX = '6E400003-B5A3-F393-E0A9-E50E24DCCA9E'

UUID_RX = '6E400002-B5A3-F393-E0A9-E50E24DCCA9E'

val_rx = "12"

uart = Bleuart(nom, UUID_UART, UUID_TX, UUID_RX)

uart.close()

def rcp_rx():

global val_rx

if uart.any():

while uart.any():

val_rx = uart.read().decode().strip()

print('sur rx: ', val_rx)

def env_tx(val_tx):

uart.write(str(val_tx) + '\n')

print("tx", val_tx)

send_1=0

send_2=0

send_3=0

send_4=0

while True:

#uart.irq(handler=rcp_rx)

level_1_value = level_1.read()

print("niveau 1",level_1_value)

level_2_value = level_2.read()

print("niveau 2",level_2_value)

level_3_value = level_3.read()

print("niveau 3",level_3_value)

level_4_value = level_4.read()

print("niveau 4",level_4_value)

if (level_1.read()==0) and (level_2.read()==0) and (level_3.read()==0) and (level_4.read()==0):

env_tx("0") # envoyer le niveau 0 d'eau au Smartphone

send_1=0

if (level_1.read()!=0) and (level_2.read()==0) and (level_3.read()==0) and (level_4.read()==0) and send_1==0:

env_tx("25") # envoyer le niveau 1 d'eau au Smartphone

send_1=1

send_2=0

if (level_1.read()!=0) and (level_2.read()!=0) and (level_3.read()==0) and (level_4.read()==0) and send_2==0:

env_tx("50") # envoyer le niveau 2 d'eau au Smartphone

send_1=0

send_2=1

send_3=0

if (level_1.read()!=0) and (level_2.read()!=0) and (level_3.read()!=0) and (level_4.read()==0) and send_3==0:

env_tx("75") # envoyer le niveau 3 d'eau au Smartphone

send_2=0

send_3=1

send_4=0

if (level_1.read()!=0) and (level_2.read()!=0) and (level_3.read()!=0) and (level_4.read()!=0) and send_4==0:

env_tx("100") # envoyer le niveau 4 d'eau au Smartphone

send_3=0

send_4=1

time.sleep_ms(500)

Programmation d'une application mobile avec App Inventor

Étape 1 : Interface utilisateur

Allez sur MIT App Inventor.

Créez un projet et ajoutez les éléments suivants :

Label pour afficher le niveau d’eau.

BluetoothClient (dans la section "Connectivité").

Bouton pour connecter le Bluetooth.

Étape 2 : Programmation des blocs

2- Utilisez les composants Bluetooth du designer pour configurer la communication avec l'ESP32.

extensions_bluetooth

- L'extension "BluetoothLE1" fait en effet référence à une extension spécifique pour MIT App Inventor qui permet de gérer la communication Bluetooth Low Energy (BLE) dans vos applications mobiles. Cette extension facilite l'interaction entre votre application App Inventor et les périphériques BLE, tels que les capteurs, les appareils de suivi, les dispositifs portables, etc.

- L'extension "BluetoothClient1" dans MIT App Inventor vous permet de créer des applications mobiles qui peuvent se connecter à des dispositifs Bluetooth, comme des modules Bluetooth série (par exemple, HC-06) connectés à des microcontrôleurs, des appareils Bluetooth audio, etc. Cette extension facilite la communication avec ces dispositifs en utilisant des connexions Bluetooth série.

3- À partir d'Android 12, les autorisations Bluetooth ont été renforcées pour améliorer la sécurité et la protection des données des utilisateurs. C'est pour cela on doit déclarer les autorisations dont votre application a besoin dans le fichier AndroidManifest.xml. Pour Bluetooth, vous devrez inclure les autorisations ACCESS_FINE_LOCATION, BLUETOOTH_SCAN, et éventuellement BLUETOOTH_CONNECT, en fonction des fonctionnalités que vous utilisez.

4- Utilisez ces blocs de programmation pour connecter le smartphone à la carte ESP32 via Bluetooth

Réception des données :

Ajoutez un événement pour lire les données Bluetooth.

Affichez les données reçues dans le label ou utilisez un graphique.

Télécharger le projet aia Télécharger le fichier apk

Avec cette solution, vous pouvez créer un système simple et efficace pour mesurer le niveau d’eau et l’afficher sur un smartphone. MIT App Inventor offre une interface intuitive pour concevoir des applications personnalisées adaptées à ce projet.