Sensore di livello liquido senza contatto XKC-Y25 con Arduino
Sensore di livello liquido senza contatto XKC-Y25: rilevamento capacitivo, spessore parete, uscita NPN/PNP e filo MODE, 5–24 V, Arduino e pompa a più livelli.
Un sensore di livello liquido senza contatto rileva se il liquido ha raggiunto una certa altezza senza infilare nulla nel serbatoio: basta incollarlo all'esterno di una parete di plastica o di vetro. L'esempio più comune ed economico è l'XKC-Y25: un piccolo disco di 28 mm di diametro, con involucro in plastica bianca e quattro fili. Poiché non tocca mai il liquido, non arrugginisce, non fa calcare, non contamina l'acqua potabile e funziona per anni anche con liquidi difficili da pulire come acidi, caffè o latte. È la soluzione più pulita al problema dei sensori di livello a forchetta dei kit Arduino, che si corrodono in poche settimane.
In questa guida imparerai come l'XKC-Y25 rileva in modo capacitivo il liquido dietro la parete e attraverso quali materiali e spessori funziona. Vedremo in dettaglio la differenza tra le versioni con uscita in tensione, NPN e PNP, i colori dei fili e il filo nero MODE, che stabilisce la logica dell'uscita. Poi collegheremo il sensore ad Arduino Uno, scriveremo un primo sketch e costruiremo un sistema che divide il serbatoio in livelli percentuali con tre sensori e gestisce la pompa da solo. Un confronto con l'interruttore a galleggiante, applicazioni per macchina del caffè e acquario e il codice per ESP32 e Raspberry Pi Pico chiudono l'articolo.

Che cos'è un sensore di livello senza contatto e come funziona?
L'XKC-Y25 è un sensore capacitivo. Sulla faccia anteriore dell'involucro c'è un elettrodo che, insieme all'ambiente circostante, forma un piccolo condensatore. Quando dietro la parete c'è solo aria, questa capacità ha un certo valore. Quando il liquido sale all'altezza del sensore, diventa parte del condensatore e la capacità aumenta. L'acqua ha una costante dielettrica di circa 80 e l'aria di 1, quindi quando arriva l'acqua la variazione di capacità è molto netta. Il chip interno misura di continuo questa variazione e commuta l'uscita quando supera una soglia. Poiché il campo elettrico attraversa materiali isolanti come plastica, vetro e ceramica, il sensore funziona senza toccare il liquido; il metallo invece scherma il campo, quindi un serbatoio metallico non si può misurare dall'esterno. Questi sono i dati del produttore per le versioni XKC-Y25-V e XKC-Y25-T12V, le più vendute:
| Caratteristica | XKC-Y25 (versione con uscita in tensione) |
|---|---|
| Tensione di alimentazione | 5–24 V CC |
| Assorbimento | Circa 5 mA |
| Uscita | Livello alto = tensione di alimentazione, livello basso = 0 V |
| Corrente di uscita | 1–50 mA |
| Tempo di risposta | Circa 500 ms |
| Spessore di parete rilevabile | 0–20 mm (fino a 12 mm consigliato per un funzionamento affidabile) |
| Temperatura di esercizio | 0–100 °C |
| Protezione | IP67, involucro in ABS |
| Dimensioni | 28 mm di diametro, circa 17 mm di profondità |
| Regolazione della sensibilità | Trimmer sotto il coperchio posteriore |
Spessore della parete, materiale e tipo di liquido
Il limite del sensore di cui si chiede di più è lo spessore della parete. Anche se il produttore indica il rilevamento fino a 20 mm, per un risultato affidabile e stabile si consiglia una parete più sottile di 12 mm. Bottiglie in PET, taniche di plastica (1–3 mm), vetro d'acquario (4–10 mm) e tubi in PVC dei progetti amatoriali rientrano ampiamente in questo limite. La faccia anteriore del sensore deve appoggiare alla parete in piano e per tutta la superficie; uno strato d'aria in mezzo riduce molto la sensibilità. Sui serbatoi cilindrici fissa quindi il sensore lungo una linea verticale, meglio con nastro biadesivo senza spugna o colla a caldo. Conta anche il tipo di liquido: i liquidi a base d'acqua come acqua, succo, caffè, latte e acqua salata si rilevano facilmente. Gli oli invece hanno una costante dielettrica di appena 2–3; con loro il sensore spesso non funziona in modo affidabile nemmeno con la sensibilità al massimo.
| Situazione | Rileva? | Nota |
|---|---|---|
| Serbatoio di plastica (PE, PP, PVC, acrilico), 1–10 mm | Sì | L'uso più comune e senza problemi |
| Barattolo di vetro, vetro d'acquario | Sì | Fino a 10 mm senza problemi; con vetro spesso alza la sensibilità |
| Ceramica | Sì | La parete deve essere piana e sottile |
| Serbatoio metallico o caldaia in acciaio inox | No | Il metallo scherma; aggiungi al serbatoio un tubo di livello in plastica |
| Plastica spessa 12–20 mm | Al limite | Alza la sensibilità e verifica i falsi interventi |
| Acqua, caffè, latte, acqua salata | Sì | Costante dielettrica alta |
| Olio, benzina, liquidi molto alcolici | Difficile o no | Costante dielettrica bassa |
| Polveri e granuli (zucchero, crocchette) | A volte | Può funzionare con polveri umide e dense, provalo sempre |
Fili, tipi di uscita e filo MODE
L'XKC-Y25 ha quattro fili e i colori sono gli stessi in tutte le versioni. Ciò a cui devi davvero fare attenzione è che lo stesso sensore, identico all'aspetto, viene venduto con diversi tipi di uscita. Il nome della versione si trova di solito sull'etichetta dell'involucro o nel nome del prodotto: XKC-Y25-V o -T12V ha l'uscita in tensione, XKC-Y25-NPN un'uscita a collettore aperto e XKC-Y25-PNP un'uscita che fornisce corrente (sourcing); esistono anche versioni RS485. Se lo colleghi senza conoscere la versione, l'uscita non cambia mai oppure porta una tensione alta ad Arduino.
| Colore del filo | Funzione | Collegamento |
|---|---|---|
| Marrone | VCC | Positivo dell'alimentazione, 5–24 V |
| Blu | GND | Negativo dell'alimentazione, in comune con il GND di Arduino |
| Giallo | OUT | Uscita del segnale, verso un ingresso di Arduino |
| Nero | MODE | Sceglie la logica di uscita: collegato a VCC o a GND |
Nella versione con uscita in tensione, se il filo nero va a VCC l'uscita lavora in "positivo": quando rileva il liquido il filo giallo è HIGH (tensione di alimentazione), senza liquido è LOW. Se il filo nero va a GND la logica si inverte: LOW con il liquido, HIGH senza. Così puoi invertire la logica per un circuito del tipo "allarme quando è vuoto" senza toccare il codice. Nella versione NPN l'uscita è un transistor che, quando è attivo, tira verso GND; quando non lo è resta flottante e si legge HIGH grazie a una resistenza di pull-up. In questa versione l'uscita funziona come "normalmente aperta" o "normalmente chiusa" a seconda che il filo nero resti libero o venga collegato a GND. Poiché ci sono piccole differenze tra un venditore e l'altro, alla prima prova avvicina la mano al serbatoio o usa un bicchiere d'acqua e misura l'uscita con il multimetro.
| Versione | Come funziona l'uscita | Arduino Uno (5 V) | ESP32 e Pico (3,3 V) |
|---|---|---|---|
| XKC-Y25-V / T12V (tensione) | Fornisce 0 V o la tensione di alimentazione | Alimenta il sensore a 5 V e collegalo direttamente | Con alimentazione a 5 V serve un partitore di tensione |
| XKC-Y25-NPN | Quando è attivo tira l'uscita a GND | Con INPUT_PULLUP; il sensore può andare a 5–24 V | La scelta più sicura, con INPUT_PULLUP |
| XKC-Y25-PNP | Quando è attivo porta la tensione di alimentazione sull'uscita | Con resistenza di pull-down e alimentazione a 5 V | Servono partitore di tensione e pull-down |
Collegamento ad Arduino Uno, ESP32 e Pico
Con Arduino Uno la strada più semplice è alimentare il sensore con uscita in tensione a 5 V; l'uscita non supera mai i 5 V e può andare direttamente su un pin digitale. ESP32 e Raspberry Pi Pico lavorano a 3,3 V, quindi qui la versione NPN è la scelta più sicura: alimenti il sensore a 5 V (o anche a 12 V) e la resistenza di pull-up interna della scheda porta l'uscita a 3,3 V. Se usi la versione in tensione su una scheda a 3,3 V, abbassa l'uscita a 3,3 V con un partitore da 10 kΩ e 20 kΩ. La tabella qui sotto mostra i pin usati dal codice di questo articolo.
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Marrone (VCC) | 5V | VIN (5 V) | VBUS (5 V) |
| Blu (GND) | GND | GND | GND |
| Nero (MODE) | 5V (HIGH con liquido) | GND o libero (NPN) | GND o libero (NPN) |
| Giallo (OUT), sensore basso | D2 | GPIO 27, INPUT_PULLUP | GP14, PULL_UP |
| OUT del sensore centrale | D3 | - | - |
| OUT del sensore alto | D4 | - | - |
| IN del modulo relè (pompa) | D7 | - | - |
| Buzzer | D8 | - | - |
Primo sketch: c'è liquido o no?
L'XKC-Y25 ha un tempo di risposta proprio di circa mezzo secondo e, mentre la superficie del liquido si muove, l'uscita può cambiare più volte. Per questo, invece di usare l'uscita direttamente, il primo sketch fa un semplice controllo di stabilità che aspetta che il valore resti uguale per 300 ms. Il codice è scritto per un sensore con uscita in tensione e il filo nero a 5 V; se la logica del tuo sensore è opposta, basta impostare la costante SIVI_VAR a LOW. A ogni cambio di stato scrive sul Monitor seriale e il LED integrato su D13 resta acceso finché c'è liquido.
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}Dopo il caricamento, fissa il sensore con il nastro all'esterno di un bicchiere di plastica vuoto e riempilo d'acqua lentamente. Quando l'acqua si avvicina al centro del sensore, il LED deve accendersi e il Monitor seriale deve scrivere "Sivi VAR". Se il sensore rileva l'acqua troppo presto o non la rileva affatto, regola la sensibilità con il trimmer; verifica prima che a serbatoio vuoto non ci siano falsi rilevamenti, poi che a serbatoio pieno il rilevamento sia stabile. Anche il piccolo LED sul retro del sensore indica lo stato; puoi guardarlo durante la regolazione senza controllare Arduino.
Più punti di livello: gestire un serbatoio con tre sensori
Un solo XKC-Y25 dice soltanto "liquido a questa altezza: sì o no". Per seguire il livello a gradini, incolla più sensori sulla parete del serbatoio ad altezze diverse. Con tre sensori lo stato si divide in quattro gradini: vuoto, basso, medio e pieno. La stessa disposizione è ideale per il riempimento automatico: la pompa parte quando il sensore basso resta all'asciutto e si ferma quando quello alto si bagna. La distanza tra i due sensori è in realtà una banda di isteresi che evita che la pompa si accenda e si spenga troppo spesso; spieghiamo questa idea in dettaglio nell'articolo su come filtrare i dati dei sensori. Il codice qui sotto aggiunge due sicurezze: se il sensore alto è bagnato mentre quello basso è asciutto, un sensore è guasto, la pompa si ferma e suona l'allarme; e se la pompa gira per più di 60 secondi senza riempire il serbatoio (sorgente vuota, tubo staccato), viene spenta anch'essa.
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}Nel codice la percentuale di livello dipende dalle altezze a cui hai incollato i sensori; se nel tuo serbatoio sono in posizioni diverse, cambia i numeri. Alcuni moduli relè si attivano con un segnale LOW; se la pompa funziona al contrario, imposta la costante RELE_ACIK a LOW. Per i dettagli sul collegamento di pompa e relè, consulta Che cos'è un modulo relè? e mini pompa d'acqua. In un sistema reale la cosa più sicura è segnalare il guasto con un pulsante o un messaggio Telegram e non riavviare la pompa finché un utente non conferma.
Confronto con interruttore a galleggiante e sensore a forchetta
L'XKC-Y25 non è l'unico modo per misurare il livello di un liquido. Nei progetti amatoriali le tre opzioni più comuni sono il sensore a forchetta con piste conduttive dei kit Arduino, l'interruttore a galleggiante, formato da un galleggiante con magnete e da un contatto reed, e il sensore capacitivo senza contatto. Quale scegliere dipende dal materiale del serbatoio, dal tipo di liquido e dal budget.
| Caratteristica | XKC-Y25 (senza contatto) | Interruttore a galleggiante | Sensore a forchetta (conduttivo) |
|---|---|---|---|
| Contatto con il liquido | Nessuno, misura dall'esterno | Sì, dentro il serbatoio | Sì, le piste sono nel liquido |
| Foro nel serbatoio | Non serve | Di solito serve | Non serve, ma il cavo entra nel serbatoio |
| Uscita | Digitale (sì/no) | Digitale (contatto) | Analogica (a gradini) |
| Durata | Lunghissima | Lunga; sporco e calcare possono bloccarlo | Breve; le piste si corrodono in pochi mesi |
| Serbatoio metallico | Non funziona | Funziona | Funziona |
| Alimenti e acqua potabile | Adatto, non tocca mai il liquido | Servono materiali per uso alimentare | Non adatto |
| Prezzo | Medio | Economico | Molto economico |
| Alimentazione | 5–24 V, circa 5 mA | Non serve, contatto passivo | 3,3–5 V, corrente durante la misura |
In breve: per prototipi e prove brevi il sensore a forchetta, per serbatoi semplici dove un foro non è un problema l'interruttore a galleggiante, e per sistemi duraturi, puliti e la cui tenuta non va compromessa l'XKC-Y25 è la scelta migliore. Per calibrare il sensore a forchetta e ridurne la corrosione, dai un'occhiata all'articolo sul sensore di livello dell'acqua.
Esempi di applicazione: macchina del caffè e acquario
Macchina del caffè e distributore d'acqua: Il serbatoio dell'acqua di una macchina del caffè domestica è di solito in plastica trasparente. Incollare un XKC-Y25 nella parte bassa del serbatoio e accendere un LED o bloccare la macchina quando l'acqua sta per finire evita che la resistenza lavori a secco. Il sensore regge fino a 100 °C, quindi le pareti calde del serbatoio non sono un problema; mettilo comunque sulla parete laterale del serbatoio, non proprio sopra la resistenza. Se aggiungi qualcosa dentro un apparecchio, stai lontano dalle parti sotto tensione di rete e lavora solo sul tuo circuito a bassa tensione.
Rabbocco automatico dell'acquario: Negli acquari l'acqua evaporata si reintegra con un serbatoio di riserva separato e una piccola pompa. Un XKC-Y25 incollato all'esterno del vetro dell'acquario o del vano filtro fa girare la pompa per qualche secondo quando il livello scende. In questo montaggio due precauzioni sono fondamentali: dai alla pompa un tempo massimo di funzionamento (come nel codice precedente) e aggiungi un secondo sensore sul serbatoio di riserva, così la pompa non gira mai a secco quando è vuoto. Prevedere un livello di "arresto di emergenza" indipendente con un altro sensore più in alto, contro il troppopieno, è una buona abitudine.
Allarme di livello basso con l'ESP32
Sull'ESP32 il montaggio più sicuro è alimentare a 5 V un sensore in versione NPN e leggerne l'uscita con la resistenza di pull-up interna. Così, qualunque sia la tensione di alimentazione del sensore, il pin dell'ESP32 non vede mai più di 3,3 V. Il codice qui sotto dà un allarme di livello basso quando il liquido manca per 2 secondi di fila, accende il LED integrato e indica da quanto tempo il livello è basso. Su questa base puoi aggiungere il Wi-Fi e inviare un messaggio allo smartphone con un bot Telegram con ESP32 oppure collegarlo a 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}Controllo del livello con Raspberry Pi Pico e MicroPython
Anche sul Raspberry Pi Pico la versione NPN con il pull-up interno è la strada più semplice e sicura. Il codice qui sotto legge il sensore su GP14, aspetta che il valore resti uguale per 1 secondo e accende o spegne il LED integrato quando lo stato cambia. Se hai un sensore con uscita in tensione e devi alimentarlo a 5 V, collega il filo giallo a GP14 tramite un partitore da 10 kΩ e 20 kΩ e usa un ingresso senza 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)Idee di progetto con l'XKC-Y25
- Serbatoio per irrigazione smart: Ferma la pompa e avvisa quando si svuota il serbatoio del progetto serra intelligente; misura l'umidità del terreno con un sensore di umidità del suolo.
- Serbatoio sul tetto o autoclave: Incolla tre sensori ad altezze diverse su un serbatoio di plastica e mostra il livello in percentuale su un display.
- Vaschetta del deumidificatore: Realizza una protezione dal troppopieno che ferma l'apparecchio e avvisa con un suono quando la vaschetta è piena.
- Ciotola dell'acqua per animali: Crea un progetto ESP32 che invia una notifica allo smartphone quando l'acqua cala.
- Dosaggio di liquidi: Rileva se il liquido passa in un tubo e impedisci alla pompa di girare a vuoto.
- Stazione per la qualità dell'acqua: Unisci il livello a un sensore TDS e a un sensore di flusso dell'acqua.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| L'uscita non cambia mai | Versione sbagliata (niente pull-up sulla NPN) o GND non in comune | Controlla l'etichetta della versione, usa INPUT_PULLUP con la NPN, unisci le masse |
| La logica con e senza liquido è invertita | Il filo MODE è collegato al contrario | Sposta il filo nero tra VCC e GND o inverti la costante SIVI_VAR nel codice |
| Non rileva nemmeno con il serbatoio pieno | Parete spessa o metallica, o aria tra sensore e parete | Incolla il sensore piatto e ben aderente, alza la sensibilità, controlla lo spessore |
| Segnala "liquido" anche a serbatoio vuoto | Sensibilità troppo alta, condensa sulla parete o una mano o del metallo vicino | Gira il trimmer in senso orario e tieni asciutta la faccia esterna della parete |
| L'uscita sfarfalla quando la superficie si muove | La superficie oscilla proprio all'altezza del sensore | Aumenta il tempo di stabilità nel codice o sposta il sensore in un punto più calmo |
| Un pin di Arduino si è scaldato o guastato | Il sensore era a 12 V e l'uscita in tensione era collegata direttamente | Usa la versione NPN o un partitore e alimenta il sensore a 5 V |
| Non funziona con liquidi oleosi | La costante dielettrica dell'olio è molto bassa | Scegli un interruttore a galleggiante o un altro metodo di misura |
| Segna pieno per un po' dopo che il livello è sceso | Un liquido denso lascia una pellicola sulla parete interna | Abbassa la sensibilità e metti il sensore dove il liquido non lascia pellicola |
Il sensore di livello liquido senza contatto XKC-Y25 è il modo più pratico per misurare il livello senza mettere nulla nel serbatoio, senza toccare il liquido e senza pensieri di ruggine. Ora che conosci il rilevamento capacitivo, il limite di spessore della parete, le versioni di uscita e il filo MODE, puoi costruire sistemi che funzioneranno per anni, dalla macchina del caffè all'acquario, dall'irrigazione delle piante al serbatoio sul tetto. Nell'app BlueGrays puoi esplorare progetti come una stazione di irrigazione intelligente, con schemi passo passo e codice pronto all'uso, e aggiungere il controllo del livello del serbatoio con l'XKC-Y25.
Domande frequenti
Come funziona un sensore di livello liquido senza contatto?
Un sensore di livello senza contatto funziona in modo capacitivo: l'elettrodo del sensore incollato alla parete esterna del serbatoio vede una capacità maggiore quando il liquido dietro sale. Quando questa variazione supera una soglia, il chip interno commuta l'uscita. Poiché il campo elettrico attraversa plastica, vetro e ceramica, il sensore funziona senza toccare il liquido.
Attraverso quale spessore di parete funziona l'XKC-Y25?
Il produttore indica un campo di rilevamento da 0 a 20 mm, ma per un funzionamento affidabile e stabile si consiglia una parete più sottile di 12 mm. Incollare il sensore piatto e senza spazi contro la parete migliora molto la sensibilità. Attraverso pareti metalliche non funziona, qualunque sia lo spessore.
L'XKC-Y25 funziona su un serbatoio metallico?
No. Una parete metallica scherma il campo elettrico del sensore, che quindi non può rilevare il liquido dall'esterno di un serbatoio di metallo. Nei serbatoi metallici si può incollare il sensore all'esterno di un tubo di livello in plastica trasparente o di una finestra di plastica collegati al serbatoio.
A cosa serve il filo nero dell'XKC-Y25?
Il filo nero è il filo MODE e sceglie la logica dell'uscita. Nella versione con uscita in tensione, se il filo nero è collegato a VCC l'uscita va HIGH quando rileva il liquido; se è collegato a GND va LOW quando rileva il liquido. Così ottieni un'uscita attiva su "pieno" o su "vuoto" senza cambiare il codice.
Come si collega l'XKC-Y25 ad Arduino?
Collega il filo marrone a 5V, il blu a GND, il giallo di uscita a un pin digitale come D2 e il nero MODE a 5V o a GND secondo la logica che vuoi. Se usi la versione NPN, imposta il pin come INPUT_PULLUP. Se alimenti il sensore a 12 V, non collegare l'uscita in tensione direttamente ad Arduino.
Meglio un sensore di livello senza contatto o un interruttore a galleggiante?
Il sensore senza contatto non tocca mai il liquido, quindi non arrugginisce né fa calcare, non richiede fori nel serbatoio ed è più adatto ad acqua potabile e alimenti. L'interruttore a galleggiante costa meno, non ha bisogno di alimentazione e funziona anche nei serbatoi metallici e con liquidi a bassa costante dielettrica come l'olio. La scelta dipende dal materiale del serbatoio e dal tipo di liquido.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Stazione di irrigazione intelligente
Un giardiniere che annaffia le tue piante da solo, così non si seccano mentre sei in vacanza.

Uso del cicalino
Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa.

Accendere un LED con un pulsante (Push)
Come un campanello: la luce resta accesa finché premi e si spegne quando lasci. L'Arduino ascolta il pulsante di continuo; mentre è premuto accende il LED, e appena togli il dito lo spegne.

LED lampeggiante
Il primissimo ciao dell'elettronica: accendere e spegnere un solo LED. L'Arduino accende e spegne il LED a intervalli brevissimi, così la luce lampeggia veloce.

LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

Sistema di Allarme Movimento ESP32 (PIR + Buzzer + LED + Telegram)
Un allarme di sicurezza smart: quando il sensore PIR rileva un movimento, suona il buzzer, si accende il LED e il proprietario riceve subito una notifica su Telegram. Un'attesa di 30 secondi (cooldown) limita la frequenza degli allarmi ripetuti; non elimina i falsi rilevamenti del sensore PIR. Adatto a casa, garage, magazzino o studio.

Raspberry Pi Pico LED Controllato da Pulsante (Push)
Primo progetto di input con Pico — lettura pulsante! LED si accende mentre il pulsante è premuto. Impara Pin.IN, Pin.PULL_UP e button.value(). GP14 LED, GP2 pulsante con PULL_UP interno. Premuto = 0, rilasciato = 1 — standard.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

