Composants · 12 min de lecture

Capteur de niveau à flotteur Arduino : pompe et cuve

Comment brancher un capteur à flotteur (float switch) sur Arduino ? Contact reed, montage NO/NC, lecture en pull-up et code Uno, ESP32, Pico pour arrêter la pompe.

Le capteur à flotteur (float switch) est le moyen le plus simple et le plus fiable de savoir avec Arduino si une cuve d'eau, un aquarium ou un réservoir d'arrosage est plein ou vide. Il contient un flotteur aimanté et un contact reed dans un tube de verre : quand le niveau d'eau pousse le flotteur vers le haut, le contact se ferme, et quand l'eau baisse, il s'ouvre. Pour l'électronique, ce capteur est donc un simple bouton actionné par l'eau : tu relies un fil à GND, l'autre à une broche numérique, et tu lis la broche avec INPUT_PULLUP.

Dans cet article, tu vas voir la structure interne du flotteur, la différence entre montage NO et NC, comment filtrer par logiciel les rebonds causés par l'eau qui bouge, et tu vas construire pas à pas un circuit à deux flotteurs qui arrête automatiquement la pompe quand la cuve est pleine. En plus des codes pour Arduino Uno, ESP32 et Raspberry Pi Pico, tu verras dans quels cas le flotteur est préférable aux capteurs à sondes conductrices, sans contact ou ultrasoniques.

Capteur de niveau d'eau à flotteur (float switch)
Capteur de niveau vertical à flotteur : flotteur aimanté, corps contenant le contact reed, partie filetée de fixation et deux fils.

Qu'est-ce qu'un capteur de niveau à flotteur et comment fonctionne-t-il ?

Au centre du capteur, dans le corps en plastique creux, se trouve un petit tube de verre rempli de gaz inerte. Dans ce tube, deux lames métalliques ferromagnétiques très proches l'une de l'autre forment le contact reed (ILS). Le flotteur, qui coulisse librement sur le corps, renferme un aimant en forme d'anneau. Quand l'eau monte, le flotteur remonte le long du corps ; lorsque l'aimant arrive à hauteur du contact reed, le champ magnétique aimante les deux lames, elles s'attirent et le circuit se ferme. Quand l'aimant s'éloigne, l'effet ressort des lames les sépare et le circuit se rouvre.

Cette conception a deux grands avantages. Premièrement, le contact électrique est entièrement enfermé dans le tube de verre : aucun métal ne touche l'eau, donc pas de corrosion par électrolyse ni d'encrassement comme avec les capteurs à sondes conductrices. Deuxièmement, la sortie est purement numérique : ouvert ou fermé. Pas de lecture analogique, de calibrage ni de bibliothèque. En revanche, le flotteur ne connaît qu'un seul point : il ne peut pas dire si l'eau est à 12 cm ou à 18 cm, il répond seulement à la question « le niveau est-il au-dessus ou en dessous de cette ligne ? ». Le même principe est utilisé dans les capteurs de porte et de fenêtre ; tu trouveras les détails dans l'article Relais reed.

CaractéristiqueValeur typique (petit modèle vertical)
Élément de détectionContact reed + aimant annulaire dans le flotteur
SortieContact sec (ouvert / fermé), 2 fils, sans polarité
Type de contactNO ou NC (se change en retournant le flotteur)
Puissance de commutation max.10 W
Tension de commutation max.100 V DC
Courant de commutation max.0,5 A
Résistance de contact100 mΩ ou moins
Matériau du corps et du flotteurPP (polypropylène)
Température de fonctionnement−10 … +85 °C
FixationCorps fileté, avec écrou et joint, au fond ou sur le couvercle de la cuve

Montage NO et NC : retourner le flotteur

La plupart des capteurs sortent de la boîte en NO (normalement ouvert) : sans eau, le flotteur repose sur la rondelle d'arrêt du bas et le contact est ouvert ; quand l'eau soulève le flotteur, le contact se ferme. L'aimant n'est pas exactement au milieu du flotteur, mais plus près d'une extrémité. Si tu retires donc la rondelle d'arrêt (circlip) au bout du corps et que tu remontes le flotteur à l'envers, la position de l'aimant par rapport au contact reed change et le capteur devient NC (normalement fermé) : fermé sans eau, ouvert quand l'eau arrive. Autre point d'attention : monter le capteur en le faisant partir du fond vers le haut ou en le suspendant depuis le couvercle change aussi la position de repos du flotteur. Quel que soit le modèle, avant de l'installer, mets le multimètre en mode continuité (bip), soulève et abaisse le flotteur à la main et observe le comportement réel.

MontageSans eau (flotteur en bas)Avec eau (flotteur en haut)Broche avec INPUT_PULLUP
NO (normalement ouvert)Contact ouvertContact ferméHIGH à sec, LOW dans l'eau
NC (normalement fermé)Contact ferméContact ouvertLOW à sec, HIGH dans l'eau
Pour les applications de sécurité comme une alarme de débordement, privilégie le montage NC. Dans un circuit NC, le contact est fermé en situation normale et la broche lit LOW ; elle passe à HIGH si l'eau monte, mais aussi si un fil casse ou si un connecteur se débranche. Une panne est ainsi détectée comme une alarme, et la pompe ne continue pas de tourner comme si de rien n'était quand le capteur est hors service en silence.

Branchement : broches Arduino Uno, ESP32 et Pico

Il n'y a pas de polarité entre les deux fils du flotteur. Il suffit de relier un fil à GND, l'autre à une broche numérique et d'activer la résistance de pull-up interne de la broche ; aucune résistance externe n'est nécessaire. Quand le contact est ouvert, la résistance de pull-up tire la broche à 5 V (3,3 V sur ESP32 et Pico) et elle lit HIGH ; quand le contact se ferme, la broche est reliée directement à GND et lit LOW. La résistance de pull-up interne de l'Uno vaut 20 à 50 kΩ ; le courant qui circule contact fermé est très faible, 5 V / 30 kΩ ≈ 0,17 mA, et ne sollicite pas du tout le contact reed. Tu trouveras les détails de la logique pull-up dans l'article Résistance pull-up et pull-down. Le tableau ci-dessous montre les broches utilisées dans tous les codes de la suite :

ConnexionArduino UnoESP32Raspberry Pi Pico
Flotteur haut (cuve pleine)D2GPIO 27GP2
Flotteur bas (cuve vide)D3GPIO 26GP3
Autres fils des flotteursGNDGNDGND
Module relais IND7GPIO 23GP15
Buzzer actif (+)D8GPIO 25GP16
Module relais VCC5VVIN (5 V)VBUS (5 V)
Ne branche jamais une pompe ou une électrovanne directement sur les fils du flotteur. Le contact reed des petits modèles ne peut commuter qu'environ 10 W et 0,5 A au maximum (les valeurs varient selon le produit, vérifie l'étiquette) ; le courant de démarrage du moteur et l'arc à l'ouverture soudent rapidement les lames dans le tube de verre, et le capteur indique alors en permanence « plein » ou « vide ». Le flotteur ne doit envoyer qu'un signal au microcontrôleur, et la charge doit être commutée par un relais ou un MOSFET. Ne fais surtout jamais passer le 220 V du secteur par le flotteur.

Pas à pas : lire le flotteur pour la première fois

  1. Mets le multimètre en mode continuité, pose ses pointes sur les deux fils du flotteur et fais glisser le flotteur de haut en bas pour déterminer s'il fonctionne en NO ou en NC.
  2. Relie un des fils à la broche GND de l'Arduino et l'autre à la broche D2. Si les fils sont fins, soude les extrémités à un fil jumper ou utilise un bornier.
  3. Téléverse le code ci-dessous ; il configure la broche en INPUT_PULLUP, donc aucune résistance supplémentaire n'est nécessaire.
  4. Ouvre le moniteur série à 9600 bauds.
  5. Pousse le flotteur vers le haut avec ton doigt : en montage NO, la LED intégrée de D13 doit s'allumer et le message « YUKSEK » doit apparaître à l'écran. Quand tu le relâches, la LED doit s'éteindre et le message « DUSUK » doit s'afficher.
C++ (Arduino IDE)
1const int FLOAT_PIN = 2;                 // şamandıra kablosu / float switch wire
2const int LED_PIN = 13;                  // dahili LED / built-in LED
3const unsigned long DEBOUNCE_MS = 300;   // dalga filtresi / ripple filter
4
5int stableState;
6int lastReading;
7unsigned long lastChange = 0;
8
9void setup() {
10  Serial.begin(9600);
11  pinMode(FLOAT_PIN, INPUT_PULLUP);      // dahili pull-up / internal pull-up
12  pinMode(LED_PIN, OUTPUT);
13  delay(10);
14  stableState = digitalRead(FLOAT_PIN);
15  lastReading = stableState;
16  digitalWrite(LED_PIN, stableState == LOW ? HIGH : LOW);
17}
18
19void loop() {
20  int reading = digitalRead(FLOAT_PIN);
21  if (reading != lastReading) {          // değişim var, sayacı sıfırla / change, reset timer
22    lastReading = reading;
23    lastChange = millis();
24  }
25  if (millis() - lastChange >= DEBOUNCE_MS && reading != stableState) {
26    stableState = reading;               // 300 ms sabit kaldı / stable for 300 ms
27    if (stableState == LOW) {            // NO: kontak kapalı = su var / NO: closed = water
28      Serial.println(F("Seviye YUKSEK: su var / Level HIGH: water present"));
29      digitalWrite(LED_PIN, HIGH);
30    } else {
31      Serial.println(F("Seviye DUSUK: su yok / Level LOW: no water"));
32      digitalWrite(LED_PIN, LOW);
33    }
34  }
35}

La partie la plus importante du code est la section de debounce (filtrage des rebonds). Dans une cuve, l'eau n'est jamais totalement calme : quand la pompe tourne, qu'on ouvre un robinet ou qu'on remplit, la surface ondule et le flotteur peut s'ouvrir et se fermer plusieurs fois par seconde au niveau du seuil. Le code remet le minuteur à zéro à chaque changement de la valeur de la broche et n'accepte la nouvelle valeur que si elle reste inchangée pendant 300 ms. C'est la même idée que le debounce des boutons, avec une durée plus longue. Dans une cuve très agitée, tu peux monter cette durée à 1 ou 2 secondes. Comme le timing est fait avec millis(), la loop n'attend jamais ; tu peux lire pourquoi dans l'article différence entre millis et delay.

Circuit qui arrête la pompe quand la cuve est pleine

On peut aussi commander une pompe avec un seul flotteur, mais il y a un problème : quand le niveau d'eau est exactement au seuil, la pompe s'allume et s'éteint toutes les quelques secondes. Cela use à la fois la pompe et le relais. La solution est l'hystérésis, c'est-à-dire l'utilisation de deux seuils distincts. Tu places un flotteur en bas de la cuve et un autre en haut. Quand l'eau descend sous le flotteur du bas, la pompe démarre ; quand elle atteint le flotteur du haut, elle s'arrête ; entre les deux, la pompe garde son état. Avec 15 cm entre les deux flotteurs et une pompe qui débite 3 litres par minute, dans une cuve de 30×40 cm de base (1200 cm²), cette zone représente 18 litres et la pompe tourne environ 6 minutes d'affilée à chaque fois. Le code effectue aussi deux contrôles de sécurité : si le flotteur du haut est dans l'eau alors que celui du bas est à sec, c'est physiquement impossible, donc un fil ou un capteur est défaillant ; et si la pompe tourne plus longtemps que prévu, la source est peut-être à sec ou un tuyau s'est détaché. Dans les deux cas, la pompe s'arrête et le buzzer sonne.

  • 2 capteurs à flotteur : pour les seuils bas et haut ; en montage NO, les deux donnent LOW dans l'eau.
  • Module relais 1 canal : il commute l'alimentation de la pompe. La plupart des modules s'enclenchent quand la broche IN passe à LOW (actif bas) ; tu règles cela dans le code avec la constante RELAY_ACTIVE_LOW. Détails dans l'article Module relais.
  • Pompe et alimentation séparée : pour une petite pompe comme une mini pompe immergée 6 V, utilise 4 piles AA ou un adaptateur 6 V ; ne tire pas le courant de la pompe sur la broche 5V de l'Arduino. Pour le choix de la pompe, consulte l'article Mini pompe à eau.
  • GND commun : si tu utilises un module relais, les GND de l'Arduino et du module sont reliés, tandis que le circuit de la pompe reste séparé via le contact du relais. Avec un MOSFET, le moins de l'alimentation de la pompe doit aussi être relié au GND de l'Arduino, et une diode 1N4007 doit être ajoutée en parallèle inverse sur la pompe.
  • Buzzer actif : il t'avertit en bipant par intermittence en cas de panne.
C++ (Arduino IDE)
1// İki şamandıra ile otomatik depo doldurma / Automatic tank filling with two floats
2const int FLOAT_PINS[2] = {2, 3};      // 0: üst şamandıra / upper float, 1: alt şamandıra / lower float
3const int RELAY_PIN  = 7;              // röle modülü IN / relay module IN
4const int BUZZER_PIN = 8;              // aktif buzzer / active buzzer
5const bool RELAY_ACTIVE_LOW = true;    // çoğu modül LOW ile çeker / most modules trigger on LOW
6const unsigned long STABLE_MS  = 500;                   // filtre süresi / filter time
7const unsigned long MAX_RUN_MS = 10UL * 60UL * 1000UL;  // en uzun çalışma: 10 dk / max run: 10 min
8
9bool wet[2];                 // true = şamandıra suda / true = float in water
10int lastRaw[2];
11unsigned long lastChange[2];
12bool pumpOn = false;
13bool fault = false;
14unsigned long pumpStart = 0;
15
16void updateSensor(int i) {
17  int raw = digitalRead(FLOAT_PINS[i]);
18  if (raw != lastRaw[i]) {             // değer değişti, sayacı sıfırla / value changed, reset timer
19    lastRaw[i] = raw;
20    lastChange[i] = millis();
21  }
22  if (millis() - lastChange[i] >= STABLE_MS) {
23    wet[i] = (raw == LOW);             // NO montaj: suda LOW / NO mount: LOW when wet
24  }
25}
26
27void setPump(bool on) {
28  pumpOn = on;
29  if (on) pumpStart = millis();
30  digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
31}
32
33void stopWithFault(const __FlashStringHelper *msg) {
34  setPump(false);
35  fault = true;                        // reset atılana kadar kilitli / latched until reset
36  Serial.println(msg);
37}
38
39void setup() {
40  Serial.begin(9600);
41  digitalWrite(RELAY_PIN, RELAY_ACTIVE_LOW ? HIGH : LOW);  // önce kapalı seviye / off level first
42  pinMode(RELAY_PIN, OUTPUT);
43  pinMode(BUZZER_PIN, OUTPUT);
44  for (int i = 0; i < 2; i++) {
45    pinMode(FLOAT_PINS[i], INPUT_PULLUP);
46  }
47  delay(10);                           // pull-up otursun / let pull-ups settle
48  for (int i = 0; i < 2; i++) {
49    lastRaw[i] = digitalRead(FLOAT_PINS[i]);
50    wet[i] = (lastRaw[i] == LOW);
51    lastChange[i] = millis();
52  }
53  Serial.println(F("Depo kontrolu basladi / Tank control started"));
54}
55
56void loop() {
57  updateSensor(0);
58  updateSensor(1);
59
60  if (!fault && wet[0] && !wet[1]) {   // üst suda, alt kuru: imkansız / upper wet, lower dry: impossible
61    stopWithFault(F("HATA: sensor tutarsiz / ERROR: sensors inconsistent"));
62  }
63  if (!fault && pumpOn && millis() - pumpStart > MAX_RUN_MS) {
64    stopWithFault(F("HATA: pompa cok uzun calisti / ERROR: pump ran too long"));
65  }
66
67  if (!fault) {
68    if (!pumpOn && !wet[1]) {          // su alt eşiğin altında / water below lower level
69      setPump(true);
70      Serial.println(F("Pompa ACIK / Pump ON"));
71    } else if (pumpOn && wet[0]) {     // depo dolu / tank full
72      setPump(false);
73      Serial.println(F("Depo dolu, pompa KAPALI / Tank full, pump OFF"));
74    }
75  }
76
77  // Arızada yarım saniyede bir bip / beep every half second on fault
78  digitalWrite(BUZZER_PIN, (fault && (millis() / 500) % 2) ? HIGH : LOW);
79}
Partie du codeRôle
updateSensor(i)Lit chaque flotteur séparément ; met à jour l'état wet[i] quand la valeur reste stable pendant 500 ms.
wet[0] / wet[1]Indique si le flotteur haut et le flotteur bas sont dans l'eau (true = dans l'eau).
!pumpOn && !wet[1]L'eau est passée sous le seuil bas : démarrer la pompe.
pumpOn && wet[0]L'eau a atteint le seuil haut : arrêter la pompe.
wet[0] && !wet[1]Haut dans l'eau, bas à sec : lecture incohérente, donc panne de fil ou de capteur.
MAX_RUN_MSSi la pompe tourne plus de 10 minutes, la protection contre le fonctionnement à sec s'active.
stopWithFault()Arrête la pompe et verrouille la panne ; pour l'effacer, résous le problème et réinitialise la carte.
RELAY_ACTIVE_LOWRègle le niveau de sortie selon que le module relais s'enclenche à LOW ou à HIGH.

Lire le flotteur et commander la pompe avec l'ESP32

Sur l'ESP32, le code est presque identique ; seuls les broches et le débit série changent. Dans cette version, chaque flotteur a une constante WET_LEVEL : si tu montes un capteur en NC, il te suffit de mettre la valeur correspondante à HIGH, le reste de la logique ne change pas. Le code écrit aussi l'état du niveau sur le port série toutes les 5 secondes ; tu pourras plus tard transformer cette ligne en code qui envoie une notification à ton téléphone via le Wi-Fi. Attention au choix des broches : les GPIO 34, 35, 36 et 39 de l'ESP32 sont uniquement des entrées et n'ont pas de résistance de pull-up interne ; si tu y branches le flotteur, tu dois ajouter un pull-up externe de 10 kΩ. Il vaut mieux aussi éviter les broches de démarrage (strapping) comme les GPIO 0, 2, 12 et 15 ; si le flotteur est fermé au démarrage, la carte peut entrer en mode programmation ou ne pas démarrer du tout. Le code compile avec l'ESP32 Arduino core 2.x comme 3.x. Si tu débutes avec l'ESP32, jette d'abord un œil à l'article Qu'est-ce que l'ESP32 ?.

C++ (Arduino IDE)
1// ESP32: iki şamandıra + röle + buzzer / two floats + relay + buzzer
2const int FLOAT_PINS[2] = {27, 26};    // 0: üst / upper, 1: alt / lower
3const int WET_LEVEL[2]  = {LOW, LOW};  // NO: suda LOW, NC ise HIGH yap / NO: LOW when wet, set HIGH for NC
4const int RELAY_PIN  = 23;             // röle modülü IN / relay module IN
5const int BUZZER_PIN = 25;             // aktif buzzer / active buzzer
6const bool RELAY_ACTIVE_LOW = true;
7const unsigned long STABLE_MS  = 500;
8const unsigned long MAX_RUN_MS = 10UL * 60UL * 1000UL;
9
10bool wet[2];
11int lastRaw[2];
12unsigned long lastChange[2];
13bool pumpOn = false;
14bool fault = false;
15unsigned long pumpStart = 0;
16unsigned long lastReport = 0;
17
18void updateSensor(int i) {
19  int raw = digitalRead(FLOAT_PINS[i]);
20  if (raw != lastRaw[i]) {
21    lastRaw[i] = raw;
22    lastChange[i] = millis();
23  }
24  if (millis() - lastChange[i] >= STABLE_MS) {
25    wet[i] = (raw == WET_LEVEL[i]);
26  }
27}
28
29void setPump(bool on) {
30  pumpOn = on;
31  if (on) pumpStart = millis();
32  digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
33}
34
35void stopWithFault(const char *msg) {
36  setPump(false);
37  fault = true;
38  Serial.println(msg);
39}
40
41void setup() {
42  Serial.begin(115200);
43  pinMode(RELAY_PIN, OUTPUT);
44  setPump(false);                      // röleyi hemen kapat / switch relay off immediately
45  pinMode(BUZZER_PIN, OUTPUT);
46  digitalWrite(BUZZER_PIN, LOW);
47  for (int i = 0; i < 2; i++) {
48    pinMode(FLOAT_PINS[i], INPUT_PULLUP);
49  }
50  delay(10);
51  for (int i = 0; i < 2; i++) {
52    lastRaw[i] = digitalRead(FLOAT_PINS[i]);
53    wet[i] = (lastRaw[i] == WET_LEVEL[i]);
54    lastChange[i] = millis();
55  }
56  Serial.println("Depo kontrolu basladi / Tank control started");
57}
58
59void loop() {
60  updateSensor(0);
61  updateSensor(1);
62
63  if (!fault && wet[0] && !wet[1]) {   // üst suda, alt kuru / upper wet, lower dry
64    stopWithFault("HATA: sensor tutarsiz / ERROR: sensors inconsistent");
65  }
66  if (!fault && pumpOn && millis() - pumpStart > MAX_RUN_MS) {
67    stopWithFault("HATA: pompa cok uzun calisti / ERROR: pump ran too long");
68  }
69
70  if (!fault) {
71    if (!pumpOn && !wet[1]) {
72      setPump(true);
73      Serial.println("Pompa ACIK / Pump ON");
74    } else if (pumpOn && wet[0]) {
75      setPump(false);
76      Serial.println("Depo dolu, pompa KAPALI / Tank full, pump OFF");
77    }
78  }
79
80  digitalWrite(BUZZER_PIN, (fault && (millis() / 500) % 2) ? HIGH : LOW);
81
82  if (millis() - lastReport >= 5000) {   // 5 sn'de bir durum raporu / status report every 5 s
83    lastReport = millis();
84    Serial.printf("Ust/Upper: %d  Alt/Lower: %d  Pompa/Pump: %d  Ariza/Fault: %d\n",
85                  (int)wet[0], (int)wet[1], (int)pumpOn, (int)fault);
86  }
87}

Code MicroPython avec le Raspberry Pi Pico

Sur le Pico, on construit la même logique en MicroPython. Le paramètre Pin.PULL_UP active la résistance de pull-up interne et peut être utilisé sur toutes les broches GP du Pico. Pour mesurer le temps, on utilise time.ticks_ms() et time.ticks_diff() ; ticks_diff calcule correctement la différence même quand le compteur déborde. Comme les sorties du Pico sont en 3,3 V, fais attention au choix du relais : certains modules à optocoupleur alimentés en 5 V peuvent ne pas se relâcher complètement avec un niveau HIGH de 3,3 V. Un module relais déclenché en 3,3 V ou un MOSFET à niveau logique est plus sûr. Si tu enregistres le code sous le nom main.py, le Pico l'exécute automatiquement à chaque démarrage. Si tu débutes en MicroPython, l'article Qu'est-ce que le Raspberry Pi Pico ? explique l'installation.

MicroPython
1from machine import Pin
2import time
3
4FLOAT_PINS = (2, 3)          # 0: üst şamandıra / upper float, 1: alt / lower
5WET_LEVEL = (0, 0)           # NO: suda 0, NC ise 1 / NO: 0 when wet, 1 for NC
6STABLE_MS = 500              # filtre süresi / filter time
7MAX_RUN_MS = 10 * 60 * 1000  # en uzun çalışma: 10 dk / max run: 10 min
8RELAY_ACTIVE_LOW = True      # röle LOW ile çekiyorsa / relay triggers on LOW
9
10relay = Pin(15, Pin.OUT, value=1 if RELAY_ACTIVE_LOW else 0)   # başlangıçta kapalı / off at start
11buzzer = Pin(16, Pin.OUT, value=0)
12sensors = [Pin(p, Pin.IN, Pin.PULL_UP) for p in FLOAT_PINS]
13time.sleep_ms(10)
14
15last_raw = [s.value() for s in sensors]
16wet = [last_raw[i] == WET_LEVEL[i] for i in range(2)]
17last_change = [time.ticks_ms(), time.ticks_ms()]
18pump_on = False
19fault = False
20pump_start = 0
21
22
23def set_pump(on):
24    global pump_on, pump_start
25    pump_on = on
26    if on:
27        pump_start = time.ticks_ms()
28    relay.value(0 if on == RELAY_ACTIVE_LOW else 1)
29
30
31def update(i):
32    raw = sensors[i].value()
33    now = time.ticks_ms()
34    if raw != last_raw[i]:                       # değer değişti / value changed
35        last_raw[i] = raw
36        last_change[i] = now
37    if time.ticks_diff(now, last_change[i]) >= STABLE_MS:
38        wet[i] = raw == WET_LEVEL[i]
39
40
41def stop_with_fault(msg):
42    global fault
43    set_pump(False)
44    fault = True
45    print(msg)
46
47
48print("Depo kontrolu basladi / Tank control started")
49while True:
50    update(0)
51    update(1)
52    if not fault and wet[0] and not wet[1]:      # üst suda, alt kuru / upper wet, lower dry
53        stop_with_fault("HATA: sensor tutarsiz / ERROR: sensors inconsistent")
54    if not fault and pump_on and time.ticks_diff(time.ticks_ms(), pump_start) > MAX_RUN_MS:
55        stop_with_fault("HATA: pompa cok uzun calisti / ERROR: pump ran too long")
56    if not fault:
57        if not pump_on and not wet[1]:           # su alt eşiğin altında / water below lower level
58            set_pump(True)
59            print("Pompa ACIK / Pump ON")
60        elif pump_on and wet[0]:                 # depo dolu / tank full
61            set_pump(False)
62            print("Depo dolu, pompa KAPALI / Tank full, pump OFF")
63    buzzer.value(1 if fault and (time.ticks_ms() // 500) % 2 else 0)
64    time.sleep_ms(10)

Flotteur ou autres capteurs de niveau d'eau : les différences

CapteurSortieAvantagesInconvénients
Flotteur (float switch)Numérique, un seul pointBon marché, aucune bibliothèque, aucun métal au contact de l'eau, longue durée de vieNe donne qu'un seuil ; saleté et algues peuvent bloquer le flotteur
Capteur de niveau d'eau à sondes conductricesAnalogiqueTrès bon marché, valeur graduelle selon la surface mouilléeS'use vite par électrolyse, ne convient pas à une immersion permanente
Capteur sans contact XKC-Y25Numérique, un seul pointSe colle à l'extérieur de la cuve, aucun perçage nécessaireNe fonctionne pas sur paroi épaisse ou métallique, plus cher
Ultrasonique (HC-SR04, JSN-SR04T)Distance continueMesure le niveau en centimètres, sans contact avec le liquideSensible à la mousse et à la vapeur, zone morte ; le HC-SR04 n'est pas étanche

La règle de choix est simple : si tu veux une réponse fiable à la question « la cuve est-elle pleine ou vide ? », le flotteur est la meilleure option. Si tu veux afficher le remplissage en pourcentage, utilise un capteur ultrasonique ; les détails sont dans l'article Comparatif des capteurs de distance. Si tu ne peux pas percer la cuve, le capteur sans contact XKC-Y25 fait l'affaire. Quant aux modules à sondes, réserve-les aux essais ou aux mesures de courte durée ; l'article Capteur de niveau d'eau explique comment prolonger la vie de ce module. Dans les systèmes sérieux, on utilise souvent les deux ensemble : le capteur ultrasonique affiche le niveau, et le flotteur attend comme protection de secours contre le débordement.

Idées de projets avec un capteur à flotteur

  • Remplissage automatique de cuve : remplis tout seul un réservoir de toit ou de jardin avec deux flotteurs et une pompe.
  • Pot intelligent et station d'arrosage : un capteur d'humidité du sol décide d'arroser, et le flotteur protège la pompe du fonctionnement à sec quand le réservoir est vide.
  • Appoint d'eau pour aquarium : compense peu à peu l'eau évaporée depuis un réservoir séparé ; un second flotteur monté en NC en haut sert de sécurité anti-débordement.
  • Alarme de bac de déshumidificateur ou de climatiseur : le buzzer sonne quand le bac est plein, ou l'alimentation de l'appareil est coupée par un relais.
  • Suivi du réservoir d'une serre : dans ton projet de serre intelligente, reçois le niveau du réservoir sur ton téléphone grâce à l'ESP32.
  • Alerte d'inondation de cave : un flotteur monté près du sol envoie un message via un bot Telegram quand l'eau s'accumule.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
La broche change sans arrêt au hasardINPUT_PULLUP oublié, broche flottanteMets pinMode en INPUT_PULLUP ou ajoute un pull-up externe de 10 kΩ
L'état est toujours inverséLe capteur fonctionne en NC ou est monté à l'enversRetourne le flotteur ou change la valeur WET_LEVEL dans le code
La pompe s'allume et s'éteint sans cesse au seuilUn seul flotteur et un temps de filtre trop courtMets en place une hystérésis avec deux flotteurs, passe le temps de filtre à 1–2 secondes
Le flotteur ne réagit jamaisContact reed soudé par surcharge ou tube de verre casséFais un test de continuité au multimètre, commute toujours la charge avec un relais
Le flotteur reste bloqué en hautSaleté, calcaire ou algues accumulésNettoie régulièrement le corps et le flotteur, place une crépine à l'arrivée d'eau
L'Arduino se réinitialise quand la pompe tourneLa pompe est alimentée par la même source, la tension chuteUtilise une alimentation séparée pour la pompe, raccorde correctement les GND
L'ESP32 ne démarre pas ou reste bloqué au démarrageLe flotteur est branché sur une broche de strappingUtilise des broches sûres comme les GPIO 26 et 27
Si les câbles du flotteur dépassent quelques mètres, ajoute juste à côté de la broche un pull-up externe de 10 kΩ et un condensateur de 100 nF entre la broche et GND. La constante de temps de ce filtre RC est de 10 kΩ × 100 nF = 1 ms ; il filtre les parasites électriques sans ralentir sensiblement la réaction du flotteur. Tu peux essayer d'autres valeurs avec le calculateur de constante de temps RC. Isole aussi les jonctions de câbles avec de la gaine thermorétractable pour les protéger de l'humidité.

Malgré sa simplicité et son faible coût, le capteur à flotteur, associé à un bon montage, une lecture en pull-up, un filtre logiciel et une hystérésis, devient la base d'une automatisation qui fonctionne sans souci pendant des années. Tu retrouves la même logique de contact reed dans les capteurs de porte, et le même contrôle de pompe dans les systèmes d'arrosage. Dans l'application BlueGrays, tu peux étudier pas à pas les projets de lecture de relais reed, de capteur de porte et de station d'arrosage intelligente, avec schémas de câblage et codes prêts à l'emploi, puis adapter le circuit de cet article à ton propre projet.

Questions fréquentes

Comment fonctionne un capteur à flotteur ?

Le flotteur contient un aimant annulaire et le corps un contact reed à tube de verre. Quand le niveau monte, le flotteur coulisse le long du corps et, lorsque l'aimant arrive à hauteur du contact reed, celui-ci se ferme ou s'ouvre. Le capteur se comporte donc comme un interrupteur actionné par l'eau et fournit un signal numérique sur ses deux fils.

Un capteur à flotteur est-il NO ou NC ?

Le même capteur peut s'utiliser des deux façons. Si tu retires la rondelle d'arrêt au bout du corps et remontes le flotteur à l'envers, un capteur NO (normalement ouvert) devient NC (normalement fermé). Comme le sens de montage influence aussi le comportement, le plus sûr est de faire un test de continuité au multimètre avant l'installation.

Faut-il une résistance pour un capteur à flotteur ?

Sur Arduino, ESP32 et Pico, si tu actives le pull-up interne de la broche (INPUT_PULLUP ou Pin.PULL_UP), aucune résistance supplémentaire n'est nécessaire. Si le câble dépasse quelques mètres ou s'il y a des parasites, un pull-up externe de 10 kΩ et un condensateur de 100 nF rendent la lecture plus stable. Les broches 34 à 39 de l'ESP32 n'ont pas de pull-up interne, donc une résistance externe y est obligatoire.

Un capteur à flotteur peut-il alimenter directement une pompe ?

Le contact reed des petits flotteurs grand public ne commute en général que 10 W et 0,5 A au maximum ; le courant de démarrage d'une pompe dépasse facilement cette limite et soude les contacts. La bonne méthode est de relier le flotteur au microcontrôleur et de piloter la pompe via un module relais ou un MOSFET. Tu peux ainsi ajouter par logiciel les protections contre le fonctionnement à sec et la durée maximale.

Un capteur à flotteur fonctionne-t-il avec l'ESP32 et le Raspberry Pi Pico ?

Oui, comme le capteur n'est qu'un interrupteur, la tension d'alimentation n'a pas d'importance et il fonctionne sans problème avec les cartes en 3,3 V. Il suffit de relier un fil à GND et l'autre à une broche GPIO avec pull-up activé. Sur l'ESP32, évite les broches de strapping et les broches 34 à 39 qui n'ont pas de pull-up interne.

Puis-je mesurer le niveau d'eau en pourcentage avec un flotteur ?

Un seul flotteur ne détecte qu'un seuil. En plaçant trois ou quatre flotteurs à différentes hauteurs de la cuve, tu peux obtenir un indicateur de pourcentage approximatif, mais pour une mesure continue et précise au centimètre, un capteur de distance ultrasonique est plus adapté. Une bonne solution est d'utiliser le capteur ultrasonique comme indicateur de niveau et le flotteur comme sécurité de secours contre le débordement.

Voir tous les projets