Capteur de niveau d’eau

Le capteur de niveau d’eau mesure la hauteur sur laquelle il est plongé : une carte à pistes conductrices alternées qui, recouvertes par l’eau, laissent passer un courant d’autant plus fort que la surface mouillée est grande. La tension lue sur la broche S augmente donc avec le niveau — vous obtenez une mesure continue, et non un simple « sec ou mouillé ».

Trois fils suffisent et rien n’est à régler : le module se lit directement sur une entrée analogique d’Arduino, d’ESP32 ou de Raspberry Pi. Les pistes de mesure sont en cuivre nu d’un côté du circuit ; l’électronique, elle, reste à l’écart de l’eau.

Caractéristiques techniques

Comment il mesure la hauteur d’eau

Les pistes du capteur sont réparties en deux groupes imbriqués : l’un relié à l’alimentation, l’autre à la sortie. À sec, rien ne les relie et la sortie reste à zéro. Dès que l’eau recouvre une partie de la carte, l’eau — conductrice — ponte les deux groupes sur toute la hauteur mouillée : la résistance entre eux chute, et la tension sur S monte proportionnellement à cette hauteur.

La sortie n’est pas étalonnée en millimètres : elle donne une valeur brute, de 0 à 1023 sur une entrée analogique d’Arduino. Ce sont vos deux propres relevés — sonde à sec, puis sonde à la hauteur maximale que vous voulez surveiller — qui fixent les seuils du programme.

Applications

• Réservoir et château d’eau — alerter quand la réserve passe sous un seuil, ou arrêter la pompe quand la cuve est pleine.
• Détection de fuite — une carte posée sous un chauffe-eau, un évier ou une machine à laver prévient dès les premières gouttes.
• Aquarium et bassin — surveiller une baisse de niveau avant que la pompe ne désamorce.
• Irrigation — croiser la mesure avec un capteur d’humidité du sol pour décider d’un arrosage.
• Poste de mesure pédagogique — afficher un pourcentage de remplissage sur un écran, sans matériel coûteux.
• Station météo connectée — relever la hauteur d’eau d’un pluviomètre maison et l’envoyer par WiFi.

Mini-projet : une jauge de niveau avec alarme

Le montage tient sur une plaque d’essai. Le capteur mesure, l’écran affiche le pourcentage de remplissage, et le buzzer sonne quand le seuil haut est atteint.

Ce qu’il faut

Le câblage

La broche + du capteur est branchée sur une sortie numérique et non sur le 5 V permanent : c’est ce qui permet au programme d’éteindre la sonde entre deux mesures, et donc de ne pas l’électrolyser.

Le programme

À copier dans l’IDE Arduino, après avoir relevé au préalable votre valeur à sec et votre valeur à pleine eau :

/*
 * Jauge de niveau d'eau - capteur resistif a pistes alternees
 * Carte   : Arduino Uno R3
 * Capteur : S -> A0, + -> D7, - -> GND
 * Buzzer  : + -> D9, - -> GND
 * Ecran   : SDA -> A4, SCL -> A5
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */
#include "Wire.h"
#include "LiquidCrystal_I2C.h"
const int BROCHE_NIVEAU = A0;    // sortie S du capteur
const int BROCHE_ALIM   = 7;     // alimentation de la sonde, allumee le temps de la mesure
const int BROCHE_BUZZER = 9;
const int SEUIL_HAUT    = 600;   // cuve pleine : on alerte
LiquidCrystal_I2C ecran(0x27, 16, 2);
// La sonde n'est alimentee que pendant la lecture : un courant continu
// permanent entre les pistes immergees electrolyse le cuivre nu et fait
// deriver la mesure en quelques semaines.
int lireNiveau(int tours) {
  long somme = 0;
  for (int i = 0; i != tours; i = i + 1) {
    digitalWrite(BROCHE_ALIM, HIGH);
    delay(20);
    somme = somme + analogRead(BROCHE_NIVEAU);
    digitalWrite(BROCHE_ALIM, LOW);
    delay(20);
  }
  return somme / tours;
}
void setup() {
  Serial.begin(9600);
  pinMode(BROCHE_ALIM, OUTPUT);
  pinMode(BROCHE_BUZZER, OUTPUT);
  digitalWrite(BROCHE_ALIM, LOW);
  digitalWrite(BROCHE_BUZZER, LOW);
  ecran.init();
  ecran.backlight();
  ecran.setCursor(0, 0);
  ecran.print("Niveau d'eau");
}
void loop() {
  int brut = lireNiveau(5);      // valeur brute, 0 a 1023
  int pourcent = brut / 10;      // 0 a 100 pour cent
  ecran.setCursor(0, 1);
  ecran.print("        ");
  ecran.setCursor(0, 1);
  ecran.print(pourcent);
  ecran.print(" %");
  Serial.print("Niveau : ");
  Serial.print(pourcent);
  Serial.println(" %");
  if (brut >= SEUIL_HAUT) {
    for (int b = 0; b != 3; b = b + 1) {
      digitalWrite(BROCHE_BUZZER, HIGH);
      delay(150);
      digitalWrite(BROCHE_BUZZER, LOW);
      delay(150);
    }
  }
  delay(1000);
}

Comment ça marche

• Cinq lectures mises en moyenne. La sortie d’un capteur résistif est bruitée ; une seule lecture fait sauter le pourcentage de plusieurs points d’un passage à l’autre.
• La sonde est alimentée par impulsions. Entre deux mesures, la broche D7 est à l’état bas : aucune tension ne traverse l’eau, donc aucune électrolyse des pistes.
• La valeur brute divisée par dix donne un pourcentage de remplissage : l’entrée analogique d’un Uno convertit la tension en un nombre de 0 à 1023.
• Le seuil haut est un choix de terrain, pas une constante du module. Relevez la valeur obtenue quand l’eau est à la hauteur maximale que vous voulez autoriser, et reportez-la dans SEUIL_HAUT.
• L’alarme est répétée trois fois puis s’arrête : une alarme continue devient vite insupportable dans une pièce de vie.

Points d’attention

• Ne plongez que la zone de pistes. Les composants, le connecteur et les soudures doivent rester au sec. Une humidité qui monte jusqu’aux broches crée des fuites de courant et fausse la lecture complète.
• N’alimentez la sonde que pendant la mesure. C’est la règle qui décide de la durée de vie du capteur : sous une tension permanente dans l’eau, le cuivre nu s’électrolyse, les pistes s’amincissent et la valeur lue dérive. Le programme du mini-projet applique déjà cette règle.
• La composition de l’eau compte. Une eau très minéralisée conduit davantage qu’une eau de pluie : la même hauteur d’eau peut donner deux valeurs différentes d’un récipient à l’autre. Étalonnez sur l’eau réellement surveillée.
• Une eau au-delà de 30 °C accélère la corrosion et fausse la mesure : ce capteur est fait pour l’eau froide ou tempérée.
• La sortie suit la tension d’alimentation. En 3,3 V, la valeur à pleine immersion est plus basse qu’en 5 V : refaites l’étalonnage si vous changez de carte. Sur un ESP32, alimentez la sonde en 3,3 V pour rester dans la plage de son convertisseur analogique-numérique.
• Rincez les pistes après un usage prolongé : un dépôt calcaire forme une couche isolante qui atténue la lecture malgré un niveau d’eau inchangé.

Questions fréquentes

Faut-il une bibliothèque pour ce capteur ?

Non. La mesure tient dans analogRead(). Seul l’afficheur LCD I2C du montage ci-dessus demande sa propre bibliothèque.

La valeur reste proche de zéro alors que la sonde est dans l’eau, pourquoi ?

Dans l’ordre : la broche + n’est pas alimentée au moment de la lecture, la sortie est branchée sur une entrée numérique au lieu d’une entrée analogique, les pistes ne sont pas mouillées parce que la carte est tenue de travers, ou l’eau est très peu conductrice (eau déminéralisée ou distillée). Une eau non conductive ne peut pas être détectée par ce principe de mesure.

Peut-on laisser le capteur immergé en permanence ?

La partie à pistes, oui, à condition de l’alimenter seulement pendant les mesures. Alimenté en continu dans l’eau, le capteur s’abîme en quelques mois et la mesure dérive bien avant cela.

Quelle hauteur d’eau peut-on mesurer ?

La zone de mesure fait environ 40 mm : au-delà, la sortie sature et le niveau n’est plus distinguable. Pour un réservoir profond, c’est le franchissement d’un seuil qui est utile — niveau bas, niveau haut — et cette hauteur suffit largement.

Peut-on obtenir une hauteur en centimètres plutôt qu’un pourcentage ?

Oui, par étalonnage : relevez la valeur lue avec 1 cm d’eau, puis avec 3 cm, et reportez ces deux points dans un calcul d’intervalle dans votre programme. La précision reste celle d’un capteur résistif, soit environ le demi-centimètre, très dépendante de la conductivité de l’eau.

À combiner avec

Pour automatiser le remplissage plutôt que de se contenter d’une alarme, ajoutez le module 1 relais 5 V commandé par la carte, et la pompe miniature 120 L/h alimentée par sa propre source — le relais ne fait que couper ou rétablir son circuit. Pour regrouper carte, plaque d’essai, fils et composants en un seul achat, le KIT Starter Arduino Uno couvre l’essentiel du mini-projet ; il ne reste qu’à y ajouter ce capteur.