Mesure d’un niveau d’eau avec un ESP32

Ce billet montre comment mesurer un niveau d’eau dans un seau, une cuve, … à l’aide d’un ESP32-WROOM et d’un capteur à ultra-sons. L’un des modèles de capteur le plus répandu est le HC-SR04. ATTENTION, ce composant fonctionne en 5 Volts et n’est donc pas compatible avec les broches de l’ESP32 qui ne supportent que du 3.3 Volts, aussi le choix s’est porté sur le module RCWL-1601 fonctionnant en 3.3 Volts. De plus le RCWL-1601 se programme exactement comme un HC-SR04

Dans cet article, les tests ont été réalisés à l’aide de l’assemblage suivant

Schéma

Pour les broches Echo et Trigger, n’importe quelle broche GPIO peut être utilisée:

Le composant RCWL-1601 a le même brochage que le HC-SR04

Le programme de tests a été écrit en micro-python utilisant le code proposé sur Github

Python

import network
import time
import machine
from machine import *
from umqtt.simple import MQTTClient

class HCSR04:
    """
    Driver to use the untrasonic sensor HC-SR04.
    The sensor range is between 2cm and 4m.
    The timeouts received listening to echo pin are converted to 
    OSError('Out of range')
    """
    # echo_timeout_us is based in chip range limit (400cm)
    def __init__(self, trigger_pin, echo_pin, echo_timeout_us=500*2*30):
        """
        trigger_pin: Output pin to send pulses
        echo_pin: Readonly pin to measure the distance. 
        echo_timeout_us: Timeout in microseconds to listen to echo pin. 
        By default is based in sensor limit range (4m)
        """
        self.echo_timeout_us = echo_timeout_us
        # Init trigger pin (out)
        self.trigger = Pin(trigger_pin, mode=Pin.OUT, pull=None)
        self.trigger.value(0)
        # Init echo pin (in)
        self.echo = Pin(echo_pin, mode=Pin.IN, pull=None)

    def _send_pulse_and_wait(self):
        """
        Send the pulse to trigger and listen on echo pin.
        We use the method `machine.time_pulse_us()` to get 
        the microseconds until the echo is received.
        """
        self.trigger.value(0) # Stabilize the sensor
        time.sleep_us(5)
        self.trigger.value(1)
        # Send a 10us pulse.
        time.sleep_us(10)
        self.trigger.value(0)
        try:
            pulse_time = machine.time_pulse_us(self.echo, 1, self.echo_timeout_us)
            return pulse_time
        except OSError as ex:
            if ex.args[0] == 110: # 110 = ETIMEDOUT
                raise OSError('Out of range')
            raise ex

    def distance_cm(self)->float:
        pulse_time = self._send_pulse_and_wait()
        """
        To calculate the distance we get the pulse_time and divide it by 2 
        (the pulse walk the distance twice) and by 29.1 becasue
        the sound speed on air (343.2 m/s), that It's equivalent to
        0.034320 cm/us that is 1cm each 29.1us
        """
        return (pulse_time / 2) / 29.1
    
def connect_wifi(ssid,passwd,maxtry=20):
    wlan=network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        wlan.connect(ssid,passwd)
        nbtry=1
        while not wlan.isconnected():
            time.sleep_ms(500)
            nbtry+=1
            if nbtry>=maxtry:
                return "timeout"
    ip,masque,x,y=wlan.ifconfig()
    return str(ip)            
    
#— MAIN ————————-
print(connect_wifi("xxxxxxxxx","xxxxxxxxxx"))
sensor = HCSR04(trigger_pin=15, echo_pin=2, echo_timeout_us=10000)
i2c = SoftI2C(scl=Pin(22), sda=Pin(21))
client = MQTTClient("testseau", "192.168.1.101", user="xxxxxxxx", password="xxxxxxxx")
client.connect()
while True:
    distance = sensor.distance_cm()
    print('Distance:', distance, 'cm')
    client.publish("testseau/valeur",str(distance))
    time.sleep(5)

Ce programme envoie toutes les 5 secondes la distance mesurée en cm sur un serveur mqtt. Cette option permet d’utiliser facilement un programme sous Windows ou Linux effectuant des statistiques:

Python

# PROGRAMME WINDOWS ou LINUX
import paho.mqtt.client as mqtt
from datetime import *
import sys

def stamp():
    s=datetime.now()
    return s.strftime("%Y-%m-%d %H:%M:%S")
    
def on_connect(client, userdata, flags, rc, properties):
    print(stamp()+" Connexion=" + str(rc))
    client.subscribe("#")

def fos(x):
    return "{:.2f}".format(x)

def cvh(d,maxi):
    x=d
    if x>maxi : x=maxi
    if x<0    : x=0
    return int(100-x*100/maxi)

def on_message(client, userdata, msg):
    global nb,somme,mini,maxi,somme_ecart,ecart_max
    if msg.topic=="testseau/valeur":
        x=str(msg.payload.decode())
        nb+=1
        y=float(x)
        somme+=y
        if y<mini: mini=y
        if y>maxi: maxi=y
        moy=somme/nb
        ecart=abs(y-moy)
        somme_ecart+=ecart
        if ecart>ecart_max: ecart_max=ecart
        w=fos(y)
        w+=" Nb val "+str(nb).zfill(5)+" Moy "+fos(moy)+" Mini "+fos(mini)+" Maxi "+fos(maxi)
        w+=" Max ecart "+fos(ecart_max)+" Ecart moyen "+fos(somme_ecart/nb)
        w+=" % "+str(cvh(y,23.34))
        print(w)
        if nb>=120:
            sys.exit()

nb=0
somme=0
mini=99999.99
maxi=-mini
ecart_max=-999999.99
somme_ecart=0
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
client.username_pw_set("xxxxxxxxxx", "xxxxxxxxx")
client.on_connect = on_connect
client.on_message = on_message
client.connect("192.168.X.XXX", 1883, 60)
client.loop_forever()

Ce programme calcule des statistiques en captant 120 valeurs reçues depuis le serveur mqtt Ce programme a été exécuté avec le seau vide, puis avec un litre d’eau, deux litres,… jusqu’à dix litres. Les résultats obtenus sont (mesures en centimètres):

Nombre de litres	Distance du capteur à la surface de l’eau	Mini	Maxi	Écart maxi	Écart moyen
0	23,75	23,68	24,25	0,58	0,03
1	21,65	21,56	21,72	0,08	0,02
2	18,44	18,38	19,38	0,94	0,03
3	15,86	15,82	15,93	0,07	0,02
4	14,32	14,21	14,38	0,11	0,03
5	10,64	10,15	11,12	0,87	0,31
6	8,39	7,56	8,45	0,57	0,04
7	4,85	4,81	4,91	0,06	0,03
8	2,78	2,73	2,85	0,07	0,03
9	2,19	2,15	2,25	0,06	0,03

Graphiquement, on voit que la courbe n’est pas tout à fait linéaire, cela est du principalement au fait que le seau n »a pas une forme cylindrique mais une forme de cône (le diamètre en bas est inférieur au diamètre en haut:

Grimeco

Mesure d’un niveau d’eau avec un ESP32

A DECOUVRIR EGALEMENT

Capteur de température et serveur MQTT

Découvrir le microbit

Laisser un commentaire Annuler la réponse