Componenti · 12 min di lettura

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.

Sensore di livello liquido senza contatto XKC-Y25
XKC-Y25: sensore capacitivo di livello liquido da 28 mm che si incolla sulla parete esterna del serbatoio.

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:

CaratteristicaXKC-Y25 (versione con uscita in tensione)
Tensione di alimentazione5–24 V CC
AssorbimentoCirca 5 mA
UscitaLivello alto = tensione di alimentazione, livello basso = 0 V
Corrente di uscita1–50 mA
Tempo di rispostaCirca 500 ms
Spessore di parete rilevabile0–20 mm (fino a 12 mm consigliato per un funzionamento affidabile)
Temperatura di esercizio0–100 °C
ProtezioneIP67, involucro in ABS
Dimensioni28 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.

SituazioneRileva?Nota
Serbatoio di plastica (PE, PP, PVC, acrilico), 1–10 mmSìL'uso più comune e senza problemi
Barattolo di vetro, vetro d'acquarioSìFino a 10 mm senza problemi; con vetro spesso alza la sensibilità
CeramicaSìLa parete deve essere piana e sottile
Serbatoio metallico o caldaia in acciaio inoxNoIl metallo scherma; aggiungi al serbatoio un tubo di livello in plastica
Plastica spessa 12–20 mmAl limiteAlza la sensibilità e verifica i falsi interventi
Acqua, caffè, latte, acqua salataSìCostante dielettrica alta
Olio, benzina, liquidi molto alcoliciDifficile o noCostante dielettrica bassa
Polveri e granuli (zucchero, crocchette)A voltePuò funzionare con polveri umide e dense, provalo sempre
La faccia esterna della parete davanti al sensore deve restare asciutta. Gocce di condensa sulla parete, uno straccio bagnato vicino o una mano sul sensore cambiano anch'essi la capacità e possono dare un falso segnale di "liquido presente". Liquidi densi come latte e caffè possono lasciare una pellicola sottile sulla parete interna quando il livello scende, e il sensore può continuare a indicare "pieno" per un po'. La sensibilità si regola aprendo il coperchio posteriore e girando il trimmer con un piccolo cacciavite: in senso antiorario aumenta, in senso orario diminuisce.

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 filoFunzioneCollegamento
MarroneVCCPositivo dell'alimentazione, 5–24 V
BluGNDNegativo dell'alimentazione, in comune con il GND di Arduino
GialloOUTUscita del segnale, verso un ingresso di Arduino
NeroMODESceglie 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.

VersioneCome funziona l'uscitaArduino Uno (5 V)ESP32 e Pico (3,3 V)
XKC-Y25-V / T12V (tensione)Fornisce 0 V o la tensione di alimentazioneAlimenta il sensore a 5 V e collegalo direttamenteCon alimentazione a 5 V serve un partitore di tensione
XKC-Y25-NPNQuando è attivo tira l'uscita a GNDCon INPUT_PULLUP; il sensore può andare a 5–24 VLa scelta più sicura, con INPUT_PULLUP
XKC-Y25-PNPQuando è attivo porta la tensione di alimentazione sull'uscitaCon resistenza di pull-down e alimentazione a 5 VServono 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.

CollegamentoArduino UnoESP32Raspberry Pi Pico
Marrone (VCC)5VVIN (5 V)VBUS (5 V)
Blu (GND)GNDGNDGND
Nero (MODE)5V (HIGH con liquido)GND o libero (NPN)GND o libero (NPN)
Giallo (OUT), sensore bassoD2GPIO 27, INPUT_PULLUPGP14, PULL_UP
OUT del sensore centraleD3--
OUT del sensore altoD4--
IN del modulo relè (pompa)D7--
BuzzerD8--
Se alimenti il sensore a 12 V o 24 V, anche l'uscita delle versioni in tensione e PNP sarà di 12–24 V; collegarla direttamente ad Arduino brucia il pin e la scheda. In quel caso usa la versione NPN oppure aggiungi un partitore di tensione o un optoisolatore. Puoi calcolare il partitore con lo strumento Partitore di tensione. Il GND del sensore e quello della scheda devono essere sempre collegati.

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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

CaratteristicaXKC-Y25 (senza contatto)Interruttore a galleggianteSensore a forchetta (conduttivo)
Contatto con il liquidoNessuno, misura dall'esternoSì, dentro il serbatoioSì, le piste sono nel liquido
Foro nel serbatoioNon serveDi solito serveNon serve, ma il cavo entra nel serbatoio
UscitaDigitale (sì/no)Digitale (contatto)Analogica (a gradini)
DurataLunghissimaLunga; sporco e calcare possono bloccarloBreve; le piste si corrodono in pochi mesi
Serbatoio metallicoNon funzionaFunzionaFunziona
Alimenti e acqua potabileAdatto, non tocca mai il liquidoServono materiali per uso alimentareNon adatto
PrezzoMedioEconomicoMolto economico
Alimentazione5–24 V, circa 5 mANon serve, contatto passivo3,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.

C++ (Arduino IDE)
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.

MicroPython
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

SintomoCausa probabileSoluzione
L'uscita non cambia maiVersione sbagliata (niente pull-up sulla NPN) o GND non in comuneControlla l'etichetta della versione, usa INPUT_PULLUP con la NPN, unisci le masse
La logica con e senza liquido è invertitaIl filo MODE è collegato al contrarioSposta il filo nero tra VCC e GND o inverti la costante SIVI_VAR nel codice
Non rileva nemmeno con il serbatoio pienoParete spessa o metallica, o aria tra sensore e pareteIncolla il sensore piatto e ben aderente, alza la sensibilità, controlla lo spessore
Segnala "liquido" anche a serbatoio vuotoSensibilità troppo alta, condensa sulla parete o una mano o del metallo vicinoGira il trimmer in senso orario e tieni asciutta la faccia esterna della parete
L'uscita sfarfalla quando la superficie si muoveLa superficie oscilla proprio all'altezza del sensoreAumenta il tempo di stabilità nel codice o sposta il sensore in un punto più calmo
Un pin di Arduino si è scaldato o guastatoIl sensore era a 12 V e l'uscita in tensione era collegata direttamenteUsa la versione NPN o un partitore e alimenta il sensore a 5 V
Non funziona con liquidi oleosiLa costante dielettrica dell'olio è molto bassaScegli un interruttore a galleggiante o un altro metodo di misura
Segna pieno per un po' dopo che il livello è scesoUn liquido denso lascia una pellicola sulla parete internaAbbassa la sensibilità e metti il sensore dove il liquido non lascia pellicola
Prima di incollare il sensore in modo definitivo, tienilo all'esterno del serbatoio con un nastro provvisorio e provalo più volte pieno, vuoto e a metà. Il LED sul retro del sensore è il tuo miglior aiuto durante la regolazione. Quando il risultato ti convince, pulisci la superficie con alcol, fissa il sensore con biadesivo permanente o colla a caldo e blocca il cavo al serbatoio in modo che non tiri il sensore.

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.

Vedi tutti i progetti
Stazione di irrigazione intelligente
AR-83Avanzato
Premium

Stazione di irrigazione intelligente

Un giardiniere che annaffia le tue piante da solo, così non si seccano mentre sei in vacanza.

5.0(42)
57
Uso del cicalino
AR-13Principiante

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.

4.7(92)
170
Accendere un LED con un pulsante (Push)
AR-9Principiante

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.

4.8(114)
253
LED lampeggiante
AR-1Principiante

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.

4.6(198)
1243
LED Lampeggiante con ESP32
ES-1Principiante

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.

4.7(37)
108
Sistema di Allarme Movimento ESP32 (PIR + Buzzer + LED + Telegram)
ES-41Avanzato
Premium

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.

9
Raspberry Pi Pico LED Controllato da Pulsante (Push)
PI-9Principiante
Premium

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.

11