Capteur de niveau de liquide sans contact XKC-Y25 avec Arduino
Capteur de niveau de liquide sans contact XKC-Y25 : détection capacitive, paroi, sortie NPN/PNP et fil MODE, 5–24 V, Arduino et pompe multi-niveaux.
Un capteur de niveau de liquide sans contact détecte si le liquide a atteint une certaine hauteur sans rien introduire dans le réservoir : il suffit de le coller à l'extérieur d'une paroi en plastique ou en verre. L'exemple le plus courant et le moins cher est le XKC-Y25 : un petit disque de 28 mm de diamètre, à boîtier en plastique blanc et à quatre fils. Comme il ne touche jamais le liquide, il ne rouille pas, ne s'entartre pas, ne contamine pas l'eau potable et fonctionne des années même avec des liquides difficiles à nettoyer comme les acides, le café ou le lait. C'est la solution la plus propre au problème des capteurs de niveau d'eau en forme de fourche des kits Arduino, qui se corrodent en quelques semaines.
Dans ce guide, tu vas apprendre comment le XKC-Y25 détecte de façon capacitive le liquide derrière la paroi, et à travers quels matériaux et quelles épaisseurs il fonctionne. On verra en détail la différence entre les versions à sortie tension, NPN et PNP, les couleurs des fils et le fil noir MODE, qui fixe la logique de sortie. Ensuite, on branchera le capteur sur un Arduino Uno, on écrira un premier programme et on construira un système qui découpe le réservoir en niveaux en pourcentage avec trois capteurs et pilote la pompe tout seul. Une comparaison avec l'interrupteur à flotteur, des applications pour cafetière et aquarium, et du code pour ESP32 et Raspberry Pi Pico terminent l'article.

Qu'est-ce qu'un capteur de niveau sans contact et comment fonctionne-t-il ?
Le XKC-Y25 est un capteur capacitif. La face avant de son boîtier contient une électrode qui forme, avec son environnement, un petit condensateur. Quand il n'y a que de l'air derrière la paroi, cette capacité a une certaine valeur. Quand le liquide monte jusqu'à la hauteur du capteur, il devient une partie de ce condensateur et la capacité augmente. L'eau a une constante diélectrique d'environ 80 et l'air de 1, donc la variation de capacité est très nette quand l'eau arrive. La puce interne mesure cette variation en permanence et bascule sa sortie lorsqu'un seuil est franchi. Comme le champ électrique traverse les matériaux isolants comme le plastique, le verre et la céramique, le capteur fonctionne sans toucher le liquide ; le métal, lui, fait écran au champ, si bien qu'un réservoir métallique ne peut pas être mesuré de l'extérieur. Voici les valeurs du fabricant pour les versions XKC-Y25-V et XKC-Y25-T12V, les plus vendues :
| Caractéristique | XKC-Y25 (version à sortie tension) |
|---|---|
| Tension d'alimentation | 5–24 V CC |
| Consommation | Environ 5 mA |
| Sortie | Niveau haut = tension d'alimentation, niveau bas = 0 V |
| Courant de sortie | 1–50 mA |
| Temps de réponse | Environ 500 ms |
| Épaisseur de paroi détectable | 0–20 mm (jusqu'à 12 mm conseillé pour un fonctionnement fiable) |
| Température de fonctionnement | 0–100 °C |
| Protection | IP67, boîtier ABS |
| Dimensions | 28 mm de diamètre, environ 17 mm de profondeur |
| Réglage de sensibilité | Potentiomètre sous le capot arrière |
Épaisseur de paroi, matériau et type de liquide
La limite du capteur dont on parle le plus est l'épaisseur de la paroi. Même si le fabricant annonce une détection jusqu'à 20 mm, une paroi de moins de 12 mm est conseillée pour un résultat fiable et stable. Les bouteilles en PET, les bidons en plastique (1–3 mm), le verre d'aquarium (4–10 mm) et les tubes en PVC des projets amateurs sont largement sous cette limite. La face avant du capteur doit toucher la paroi à plat et sur toute sa surface ; une lame d'air réduit fortement la sensibilité. Sur les réservoirs cylindriques, fixe donc le capteur le long d'une ligne verticale, de préférence avec un adhésif double face sans mousse ou de la colle chaude. Le type de liquide compte aussi : les liquides à base d'eau comme l'eau, le jus, le café, le lait ou l'eau salée sont facilement détectés. Les huiles, en revanche, n'ont qu'une constante diélectrique d'environ 2 à 3 ; avec elles, le capteur ne fonctionne souvent pas de façon fiable, même à sensibilité maximale.
| Situation | Détecte-t-il ? | Remarque |
|---|---|---|
| Réservoir plastique (PE, PP, PVC, acrylique), 1–10 mm | Oui | L'usage le plus courant et le plus simple |
| Bocal en verre, verre d'aquarium | Oui | Facile jusqu'à 10 mm ; augmente la sensibilité pour un verre épais |
| Céramique | Oui | La paroi doit être plane et fine |
| Réservoir métallique ou chaudière inox | Non | Le métal fait écran ; ajoute un tube de niveau en plastique au réservoir |
| Plastique de 12–20 mm | Limite | Augmente la sensibilité et teste les faux déclenchements |
| Eau, café, lait, eau salée | Oui | Constante diélectrique élevée |
| Huile, essence, liquides très alcoolisés | Difficile ou non | Constante diélectrique faible |
| Poudres et granulés (sucre, croquettes) | Parfois | Possible avec une poudre humide et dense, teste toujours |
Fils, types de sortie et fil MODE
Le XKC-Y25 a quatre fils, et leurs couleurs sont les mêmes pour toutes les versions. Ce qu'il faut vraiment surveiller, c'est que le même capteur en apparence est vendu avec différents types de sortie. Le nom de la version figure en général sur l'étiquette du boîtier ou dans le nom du produit : XKC-Y25-V ou -T12V a une sortie tension, XKC-Y25-NPN une sortie à collecteur ouvert et XKC-Y25-PNP une sortie qui fournit du courant (sourcing) ; il existe aussi des versions RS485. Si tu le branches sans connaître la version, la sortie ne change jamais ou elle envoie une tension élevée dans l'Arduino.
| Couleur du fil | Fonction | Branchement |
|---|---|---|
| Marron | VCC | Plus de l'alimentation, 5–24 V |
| Bleu | GND | Moins de l'alimentation, commun avec le GND de l'Arduino |
| Jaune | OUT | Sortie du signal, vers une entrée de l'Arduino |
| Noir | MODE | Choisit la logique de sortie : relié à VCC ou au GND |
Sur la version à sortie tension, si le fil noir est relié au VCC, la sortie fonctionne en « positif » : quand du liquide est détecté, le fil jaune est à HIGH (tension d'alimentation), et à LOW en l'absence de liquide. Si le fil noir est relié au GND, la logique s'inverse : LOW avec du liquide, HIGH sans. Tu peux ainsi inverser la logique pour un circuit du type « alarme quand c'est vide » sans toucher au code. Sur la version NPN, la sortie est un transistor qui tire vers le GND quand il est actif ; inactif, il reste en l'air et se lit HIGH grâce à une résistance de pull-up. Sur cette version, la sortie fonctionne en « normalement ouvert » ou « normalement fermé » selon que le fil noir reste libre ou est relié au GND. Comme il existe de petites différences d'un vendeur à l'autre, lors du premier essai, approche ta main du réservoir ou utilise un verre d'eau et mesure la sortie au multimètre.
| Version | Fonctionnement de la sortie | Arduino Uno (5 V) | ESP32 et Pico (3,3 V) |
|---|---|---|---|
| XKC-Y25-V / T12V (tension) | Donne 0 V ou la tension d'alimentation | Alimente le capteur en 5 V et branche directement | Un pont diviseur est obligatoire avec une alimentation 5 V |
| XKC-Y25-NPN | Tire la sortie vers le GND quand il est actif | Avec INPUT_PULLUP ; le capteur peut être en 5–24 V | L'option la plus sûre, avec INPUT_PULLUP |
| XKC-Y25-PNP | Met la tension d'alimentation sur la sortie quand il est actif | Avec une résistance de pull-down et une alimentation 5 V | Pont diviseur et pull-down nécessaires |
Branchement sur Arduino Uno, ESP32 et Pico
Avec un Arduino Uno, le plus simple est d'alimenter le capteur à sortie tension en 5 V ; la sortie ne dépasse alors jamais 5 V et peut aller directement sur une broche numérique. L'ESP32 et le Raspberry Pi Pico fonctionnent en 3,3 V, la version NPN est donc ici le choix le plus sûr : tu alimentes le capteur en 5 V (voire en 12 V) et la résistance de pull-up interne de la carte ramène la sortie à 3,3 V. Si tu utilises la version tension sur une carte 3,3 V, abaisse la sortie à 3,3 V avec un pont diviseur de 10 kΩ et 20 kΩ. Le tableau ci-dessous donne les broches utilisées par le code de cet article.
| Liaison | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Marron (VCC) | 5V | VIN (5 V) | VBUS (5 V) |
| Bleu (GND) | GND | GND | GND |
| Noir (MODE) | 5V (HIGH avec liquide) | GND ou libre (NPN) | GND ou libre (NPN) |
| Jaune (OUT), capteur bas | D2 | GPIO 27, INPUT_PULLUP | GP14, PULL_UP |
| OUT du capteur du milieu | D3 | - | - |
| OUT du capteur haut | D4 | - | - |
| IN du module relais (pompe) | D7 | - | - |
| Buzzer | D8 | - | - |
Premier programme : liquide ou pas ?
Le XKC-Y25 a un temps de réponse propre d'environ une demi-seconde, et quand la surface du liquide ondule, la sortie peut changer plusieurs fois. Plutôt que d'utiliser la sortie directement, le premier programme fait donc une simple vérification de stabilité qui attend que la valeur reste identique pendant 300 ms. Le code est écrit pour un capteur à sortie tension avec le fil noir relié au 5 V ; si la logique de ton capteur est inversée, il suffit de mettre la constante SIVI_VAR à LOW. Il écrit dans le moniteur série à chaque changement d'état, et la LED intégrée sur D13 s'allume tant qu'il y a du liquide.
1const int SENSOR_PIN = 2; // XKC-Y25 sarı kablo / yellow wire
2const int LED_PIN = 13; // dahili LED / onboard LED
3const int SIVI_VAR = HIGH; // siyah kablo 5V'ta: sıvı varken HIGH / black wire on 5V: HIGH when liquid
4const unsigned long KARARLI_MS = 300; // değer bu kadar sabit kalmalı / value must stay this long
5
6int sonOkunan = -1;
7int kararliDurum = -1;
8unsigned long degisimZamani = 0;
9
10void setup() {
11 Serial.begin(9600);
12 pinMode(SENSOR_PIN, INPUT); // NPN sürümde INPUT_PULLUP / INPUT_PULLUP for the NPN version
13 pinMode(LED_PIN, OUTPUT);
14}
15
16void loop() {
17 int okunan = digitalRead(SENSOR_PIN);
18 if (okunan != sonOkunan) { // ham değer değişti / raw value changed
19 sonOkunan = okunan;
20 degisimZamani = millis();
21 }
22 if (millis() - degisimZamani >= KARARLI_MS && okunan != kararliDurum) {
23 kararliDurum = okunan; // 300 ms sabit kaldı, kabul et / stable for 300 ms, accept it
24 bool siviVar = (kararliDurum == SIVI_VAR);
25 digitalWrite(LED_PIN, siviVar ? HIGH : LOW);
26 Serial.println(siviVar ? "Sivi VAR / Liquid detected" : "Sivi YOK / No liquid");
27 }
28}Après le téléversement, colle le capteur avec du ruban adhésif à l'extérieur d'un gobelet en plastique vide et remplis-le lentement d'eau. Quand l'eau approche du centre du capteur, la LED doit s'allumer et le moniteur série afficher « Sivi VAR ». Si le capteur détecte l'eau beaucoup trop tôt ou pas du tout, règle la sensibilité au potentiomètre ; vérifie d'abord qu'il n'y a pas de fausse détection réservoir vide, puis que la détection est stable réservoir plein. La petite LED au dos du capteur indique aussi l'état de détection ; tu peux la surveiller pendant le réglage sans regarder l'Arduino.
Plusieurs points de niveau : gérer un réservoir avec trois capteurs
Un seul XKC-Y25 dit seulement « liquide à cette hauteur : oui ou non ». Pour suivre le niveau par paliers, colle plusieurs capteurs sur la paroi du réservoir à des hauteurs différentes. Avec trois capteurs, l'état se divise en quatre paliers : vide, bas, moyen et plein. La même disposition est idéale pour le remplissage automatique : la pompe démarre quand le capteur du bas devient sec et s'arrête quand celui du haut est mouillé. L'écart entre les deux capteurs est en fait une bande d'hystérésis qui évite que la pompe s'allume et s'éteigne trop souvent ; on explique cette idée en détail dans l'article sur le filtrage des données de capteur. Le code ci-dessous ajoute deux sécurités : si le capteur du haut est mouillé alors que celui du bas est sec, un capteur est défaillant, la pompe s'arrête et l'alarme sonne ; et si la pompe tourne plus de 60 secondes sans remplir le réservoir (source vide, tuyau débranché), elle est également coupée.
1const int ALT_PIN = 2; // %20 hizası / at 20%
2const int ORTA_PIN = 3; // %50 hizası / at 50%
3const int UST_PIN = 4; // %90 hizası / at 90%
4const int RELE_PIN = 7; // pompa rölesi / pump relay
5const int BUZZER_PIN = 8;
6const int SIVI_VAR = HIGH; // sensör mantığı / sensor logic
7const int RELE_ACIK = HIGH; // düşük tetiklemeli röle için LOW / LOW for active-low relays
8const unsigned long EN_UZUN_POMPA_MS = 60000; // 60 sn güvenlik sınırı / 60 s safety limit
9
10bool pompaCalisiyor = false;
11bool arizaVar = false;
12unsigned long pompaBaslangic = 0;
13
14bool siviVar(int pin) {
15 return digitalRead(pin) == SIVI_VAR;
16}
17
18void pompa(bool ac) {
19 if (ac && !pompaCalisiyor) pompaBaslangic = millis();
20 pompaCalisiyor = ac;
21 digitalWrite(RELE_PIN, ac ? RELE_ACIK : !RELE_ACIK);
22}
23
24void setup() {
25 Serial.begin(9600);
26 pinMode(ALT_PIN, INPUT);
27 pinMode(ORTA_PIN, INPUT);
28 pinMode(UST_PIN, INPUT);
29 pinMode(RELE_PIN, OUTPUT);
30 pinMode(BUZZER_PIN, OUTPUT);
31 pompa(false);
32}
33
34void loop() {
35 bool alt = siviVar(ALT_PIN);
36 bool orta = siviVar(ORTA_PIN);
37 bool ust = siviVar(UST_PIN);
38
39 int seviye = 0; // yüzde / percent
40 if (alt) seviye = 20;
41 if (alt && orta) seviye = 50;
42 if (alt && orta && ust) seviye = 90;
43
44 // Mantıksız durum: üst ıslak ama alt kuru / impossible state: top wet but bottom dry
45 if ((ust && !alt) || (orta && !alt) || (ust && !orta)) {
46 arizaVar = true;
47 }
48 // Pompa çok uzun çalıştı / pump ran too long
49 if (pompaCalisiyor && millis() - pompaBaslangic > EN_UZUN_POMPA_MS) {
50 arizaVar = true;
51 }
52
53 if (arizaVar) {
54 pompa(false);
55 tone(BUZZER_PIN, 2000, 200); // ariza alarmı / fault alarm
56 Serial.println("ARIZA: sensorleri ve pompayi kontrol et / FAULT: check sensors and pump");
57 delay(1000);
58 return; // ariza resetle silinir / fault is cleared by reset
59 }
60
61 if (!alt && !pompaCalisiyor) pompa(true); // alt kurudu: doldur / bottom dry: fill
62 if (ust && pompaCalisiyor) pompa(false); // üst ıslandı: dur / top wet: stop
63
64 Serial.print("Seviye / Level: %");
65 Serial.print(seviye);
66 Serial.print(" Pompa / Pump: ");
67 Serial.println(pompaCalisiyor ? "ACIK / ON" : "KAPALI / OFF");
68 delay(500);
69}Dans le code, le pourcentage de niveau dépend des hauteurs où tu as collé les capteurs ; si tu les as placés autrement sur ton réservoir, modifie les nombres. Certains modules relais s'activent sur un signal LOW ; si la pompe fonctionne à l'envers, mets la constante RELE_ACIK à LOW. Pour les détails du branchement de la pompe et du relais, consulte Qu'est-ce qu'un module relais ? et mini pompe à eau. Dans un vrai système, le plus sûr est de signaler la panne par un bouton ou un message Telegram et de ne pas relancer la pompe avant la confirmation d'un utilisateur.
Comparaison avec l'interrupteur à flotteur et le capteur à fourche
Le XKC-Y25 n'est pas le seul moyen de mesurer un niveau de liquide. Dans les projets amateurs, on rencontre surtout trois options : le capteur à fourche à pistes conductrices des kits Arduino, l'interrupteur à flotteur, composé d'un flotteur aimanté et d'un contact reed, et le capteur capacitif sans contact. Le bon choix dépend du matériau du réservoir, du type de liquide et du budget.
| Caractéristique | XKC-Y25 (sans contact) | Interrupteur à flotteur | Capteur à fourche (conducteur) |
|---|---|---|---|
| Contact avec le liquide | Aucun, mesure de l'extérieur | Oui, dans le réservoir | Oui, les pistes sont dans le liquide |
| Trou dans le réservoir | Inutile | Souvent nécessaire | Inutile, mais le câble entre dans le réservoir |
| Sortie | Numérique (oui/non) | Numérique (contact) | Analogique (par paliers) |
| Durée de vie | Très longue | Longue ; saleté et calcaire peuvent le bloquer | Courte ; les pistes se corrodent en quelques mois |
| Réservoir métallique | Ne fonctionne pas | Fonctionne | Fonctionne |
| Alimentaire et eau potable | Adapté, ne touche jamais le liquide | Matériaux de qualité alimentaire nécessaires | Non adapté |
| Prix | Moyen | Bon marché | Très bon marché |
| Alimentation | 5–24 V, environ 5 mA | Aucune, contact passif | 3,3–5 V, courant pendant la mesure |
En résumé : pour les prototypes et les essais courts, le capteur à fourche ; pour les réservoirs simples où un trou n'est pas gênant, l'interrupteur à flotteur ; et pour des systèmes durables, propres et dont l'étanchéité ne doit pas être percée, le XKC-Y25 est le meilleur choix. Pour étalonner le capteur à fourche et limiter sa corrosion, jette un œil à l'article sur le capteur de niveau d'eau.
Exemples d'application : cafetière et aquarium
Cafetière et fontaine à eau : Le réservoir d'eau d'une cafetière domestique est souvent en plastique transparent. Coller un XKC-Y25 en bas du réservoir et allumer une LED ou bloquer la machine quand l'eau va manquer évite que la résistance chauffe à sec. Le capteur supporte jusqu'à 100 °C, les parois chaudes ne posent donc pas de problème ; place-le quand même sur la paroi latérale du réservoir, pas juste au-dessus de la résistance. Si tu ajoutes quelque chose dans un appareil, reste loin des parties sous tension secteur et ne travaille que sur ton propre circuit basse tension.
Remise à niveau automatique d'un aquarium : Dans les aquariums, on compense l'eau évaporée avec un réservoir d'appoint séparé et une petite pompe. Un XKC-Y25 collé à l'extérieur de la vitre de l'aquarium ou du compartiment filtre fait tourner la pompe quelques secondes quand le niveau baisse. Deux précautions sont essentielles : donne à la pompe une durée de fonctionnement maximale (comme dans le code précédent) et ajoute un second capteur sur le réservoir d'appoint pour que la pompe ne tourne jamais à sec quand il est vide. Prévoir un niveau « arrêt d'urgence » indépendant avec un autre capteur placé plus haut, contre les débordements, est une bonne habitude.
Alarme de niveau bas avec l'ESP32
Sur l'ESP32, le montage le plus sûr consiste à alimenter un capteur en version NPN en 5 V et à lire sa sortie avec la résistance de pull-up interne. Ainsi, quelle que soit la tension d'alimentation du capteur, la broche de l'ESP32 ne voit jamais plus de 3,3 V. Le code ci-dessous déclenche une alarme de niveau bas quand le liquide est absent pendant 2 secondes sans interruption, allume la LED intégrée et indique depuis combien de temps le niveau est bas. Sur cette base, tu peux ajouter le Wi-Fi et envoyer un message sur ton téléphone avec un bot Telegram ESP32 ou le relier à Home Assistant via MQTT.
1const int SENSOR_PIN = 27; // NPN çıkış, dahili pull-up / NPN output, internal pull-up
2const int LED_PIN = 2; // dahili LED / onboard LED
3const int SIVI_VAR = LOW; // NPN: sıvı varken GND'ye çeker / NPN: pulls to GND when liquid
4const unsigned long ONAY_MS = 2000; // 2 sn onay / 2 s confirmation
5
6bool alarmAktif = false;
7unsigned long yokBaslangic = 0;
8bool yokSayiliyor = false;
9
10void setup() {
11 Serial.begin(115200);
12 pinMode(SENSOR_PIN, INPUT_PULLUP);
13 pinMode(LED_PIN, OUTPUT);
14}
15
16void loop() {
17 bool siviVar = (digitalRead(SENSOR_PIN) == SIVI_VAR);
18
19 if (!siviVar) {
20 if (!yokSayiliyor) {
21 yokSayiliyor = true;
22 yokBaslangic = millis();
23 }
24 if (!alarmAktif && millis() - yokBaslangic >= ONAY_MS) {
25 alarmAktif = true;
26 digitalWrite(LED_PIN, HIGH);
27 Serial.println("DUSUK SEVIYE! / LOW LEVEL!");
28 }
29 } else {
30 yokSayiliyor = false;
31 if (alarmAktif) {
32 alarmAktif = false;
33 digitalWrite(LED_PIN, LOW);
34 Serial.println("Seviye normal / Level OK");
35 }
36 }
37
38 static unsigned long sonRapor = 0;
39 if (alarmAktif && millis() - sonRapor >= 10000) { // 10 sn'de bir hatırlat / remind every 10 s
40 sonRapor = millis();
41 Serial.printf("Dusuk seviye suresi / Low level for: %lu s\n",
42 (unsigned long)((millis() - yokBaslangic) / 1000));
43 }
44 delay(50);
45}Suivi de niveau avec le Raspberry Pi Pico et MicroPython
Sur le Raspberry Pi Pico aussi, la version NPN avec le pull-up interne est la solution la plus simple et la plus sûre. Le code ci-dessous lit le capteur sur GP14, attend que la valeur reste identique pendant 1 seconde et allume ou éteint la LED intégrée quand l'état change. Si tu as un capteur à sortie tension que tu dois alimenter en 5 V, relie le fil jaune à GP14 à travers un pont de 10 kΩ et 20 kΩ et utilise une entrée sans Pin.PULL_UP.
1from machine import Pin
2import time
3
4sensor = Pin(14, Pin.IN, Pin.PULL_UP) # NPN çıkış / NPN output
5led = Pin(25, Pin.OUT) # Pico W'da Pin("LED") / Pin("LED") on Pico W
6SIVI_VAR = 0 # NPN: sıvı varken 0 / NPN: 0 when liquid
7ONAY_MS = 1000
8
9kararli = None
10son_okunan = sensor.value()
11degisim = time.ticks_ms()
12
13while True:
14 okunan = sensor.value()
15 if okunan != son_okunan: # ham değer değişti / raw value changed
16 son_okunan = okunan
17 degisim = time.ticks_ms()
18 if time.ticks_diff(time.ticks_ms(), degisim) >= ONAY_MS and okunan != kararli:
19 kararli = okunan
20 sivi_var = (kararli == SIVI_VAR)
21 led.value(1 if sivi_var else 0)
22 print("Sivi VAR / Liquid" if sivi_var else "Sivi YOK / No liquid")
23 time.sleep_ms(20)Idées de projets avec le XKC-Y25
- Réservoir d'arrosage intelligent : Arrête la pompe et préviens quand le réservoir du projet de serre intelligente est vide ; mesure l'humidité de la terre avec un capteur d'humidité du sol.
- Cuve de toit ou surpresseur : Colle trois capteurs à différentes hauteurs sur une cuve en plastique et affiche le niveau en pourcentage sur un écran.
- Bac de déshumidificateur : Crée une protection anti-débordement qui arrête l'appareil et prévient par un son quand le bac est plein.
- Gamelle d'eau pour animaux : Monte un projet ESP32 qui envoie une notification sur ton téléphone quand l'eau baisse.
- Dosage de liquides : Détecte si du liquide passe dans un tuyau ou un tube et évite que la pompe tourne à vide.
- Station de qualité de l'eau : Associe le niveau à un capteur TDS et à un capteur de débit d'eau.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| La sortie ne change jamais | Mauvaise version supposée (pas de pull-up sur la NPN) ou GND non commun | Vérifie l'étiquette de version, utilise INPUT_PULLUP en NPN, relie les masses |
| La logique avec et sans liquide est inversée | Le fil MODE est dans l'autre sens | Déplace le fil noir entre VCC et GND ou inverse la constante SIVI_VAR dans le code |
| Ne détecte rien même réservoir plein | Paroi épaisse ou métallique, ou air entre capteur et paroi | Colle le capteur bien à plat, augmente la sensibilité, vérifie l'épaisseur de paroi |
| Indique « liquide » même réservoir vide | Sensibilité trop haute, condensation sur la paroi ou main ou métal à proximité | Tourne le potentiomètre dans le sens horaire et garde la face extérieure sèche |
| La sortie clignote quand la surface ondule | La surface bouge juste à la hauteur du capteur | Augmente le délai de stabilité dans le code ou déplace le capteur vers une zone plus calme |
| Une broche de l'Arduino a chauffé ou a lâché | Le capteur était en 12 V et la sortie tension branchée directement | Utilise la version NPN ou un pont diviseur et alimente le capteur en 5 V |
| Ne fonctionne pas avec des liquides huileux | La constante diélectrique de l'huile est très faible | Choisis un interrupteur à flotteur ou une autre méthode de mesure |
| Indique plein un moment après la baisse du niveau | Un liquide épais laisse un film sur la paroi intérieure | Baisse la sensibilité et place le capteur là où le liquide ne laisse pas de film |
Le capteur de niveau de liquide sans contact XKC-Y25 est le moyen le plus pratique de mesurer un niveau sans rien mettre dans le réservoir, sans toucher le liquide et sans souci de rouille. Maintenant que tu connais la détection capacitive, la limite d'épaisseur de paroi, les versions de sortie et le fil MODE, tu peux construire des systèmes qui tourneront des années, de la cafetière à l'aquarium, de l'arrosage des plantes à la cuve sur le toit. Dans l'application BlueGrays, tu peux explorer des projets comme une station d'arrosage intelligente, avec des schémas pas à pas et du code prêt à l'emploi, et y ajouter le contrôle du niveau du réservoir avec le XKC-Y25.
Questions fréquentes
Comment fonctionne un capteur de niveau de liquide sans contact ?
Un capteur de niveau sans contact fonctionne de façon capacitive : l'électrode du capteur collé sur la paroi extérieure du réservoir voit une capacité plus grande quand le liquide derrière monte. Quand cette variation dépasse un seuil, la puce interne bascule la sortie. Comme le champ électrique traverse le plastique, le verre et la céramique, le capteur fonctionne sans toucher le liquide.
À travers quelle épaisseur de paroi le XKC-Y25 fonctionne-t-il ?
Le fabricant indique une plage de détection de 0 à 20 mm, mais une paroi de moins de 12 mm est conseillée pour un fonctionnement fiable et stable. Coller le capteur à plat et sans espace contre la paroi améliore nettement la sensibilité. Il ne fonctionne pas à travers une paroi métallique, quelle que soit son épaisseur.
Le XKC-Y25 fonctionne-t-il sur un réservoir métallique ?
Non. Une paroi métallique fait écran au champ électrique du capteur, qui ne peut donc pas détecter le liquide depuis l'extérieur d'un réservoir en métal. Sur un réservoir métallique, on peut coller le capteur à l'extérieur d'un tube de niveau en plastique transparent ou d'une fenêtre en plastique reliés au réservoir.
À quoi sert le fil noir du XKC-Y25 ?
Le fil noir est le fil MODE et choisit la logique de sortie. Sur la version à sortie tension, si le fil noir est relié au VCC, la sortie passe à HIGH quand du liquide est détecté ; s'il est relié au GND, elle passe à LOW. Tu obtiens ainsi une sortie active sur « plein » ou sur « vide » sans modifier le code.
Comment brancher le XKC-Y25 sur un Arduino ?
Relie le fil marron au 5V, le bleu au GND, le jaune de sortie à une broche numérique comme D2 et le noir MODE au 5V ou au GND selon la logique voulue. Avec la version NPN, configure la broche en INPUT_PULLUP. Si tu alimentes le capteur en 12 V, ne branche pas la sortie tension directement sur l'Arduino.
Capteur de niveau sans contact ou interrupteur à flotteur : lequel choisir ?
Le capteur sans contact ne touche jamais le liquide : il ne rouille pas, ne s'entartre pas, ne demande aucun trou dans le réservoir et convient mieux à l'eau potable et aux aliments. L'interrupteur à flotteur est moins cher, n'a pas besoin d'alimentation et fonctionne aussi dans les réservoirs métalliques et avec des liquides à faible constante diélectrique comme l'huile. Le choix dépend du matériau du réservoir et du type de liquide.
Projets à réaliser après cet article
Voir tous les projets
Station d'irrigation intelligente
Un jardinier qui arrose tes plantes tout seul pour qu'elles ne sèchent pas pendant tes vacances.

Utilisation du buzzer
Tu t'es déjà demandé comment une sonnette ou une alarme produit son son ? L'Arduino fait biper un petit buzzer à intervalles courts : bip, silence, bip, silence.

Allumer une LED avec un bouton-poussoir (Push)
Comme une sonnette : la lumière reste allumée tant que tu appuies et s'éteint quand tu relâches.

Clignotement d'une LED
Le tout premier bonjour de l'électronique : allumer et éteindre une seule LED. L'Arduino allume et éteint la LED à intervalles très courts, la lumière clignote donc rapidement.

Clignotement LED avec ESP32
Enseigne l'utilisation de base des sorties GPIO avec l'ESP32. Nous obtenons un effet de clignotement en allumant et éteignant une LED à partir de la broche numérique. Version ESP32 du projet blink classique sur Arduino UNO ; les commandes de base de blink dans l'environnement Arduino restent les mêmes, mais le brochage et les niveaux GPIO de 3,3 V de l'ESP32 diffèrent de ceux de l'Arduino UNO.

Système d'Alarme de Mouvement ESP32 (PIR + Buzzer + LED + Telegram)
Une alarme de sécurité intelligente : quand le capteur PIR détecte un mouvement, le buzzer sonne, la LED s'allume et le propriétaire reçoit aussitôt une notification Telegram. Un délai de 30 secondes (cooldown) limite la répétition des alarmes ; il n'élimine pas les fausses détections du capteur PIR. À utiliser à la maison, au garage, dans une réserve ou un bureau.

Raspberry Pi Pico LED Contrôlée par Bouton (Push)
Premier projet entrée avec Pico — lecture bouton ! LED s'allume tant que le bouton est pressé. Apprends Pin.IN, Pin.PULL_UP et button.value(). GP14 LED, GP2 bouton avec PULL_UP interne. Pressé = 0, relâché = 1 — standard.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

