Sensore a galleggiante Arduino: pompa con float switch
Come collegare un sensore a galleggiante (float switch) ad Arduino? Contatto reed, NO/NC, pull-up e codice Uno, ESP32 e Pico per fermare la pompa.
Il sensore a galleggiante (float switch) è il modo più semplice e affidabile per capire con Arduino se un serbatoio d'acqua, un acquario o una cisterna per l'irrigazione è pieno o vuoto. Dentro ci sono un galleggiante con magnete e un contatto reed in un tubicino di vetro: quando il livello dell'acqua spinge su il galleggiante il contatto si chiude, quando l'acqua scende si riapre. Dal punto di vista elettronico il sensore è quindi come un pulsante premuto dall'acqua: colleghi un filo a GND, l'altro a un pin digitale e leggi il pin con INPUT_PULLUP.
In questo articolo vedrai la struttura interna del galleggiante, la differenza tra montaggio NO e NC, come filtrare via software le oscillazioni dell'acqua e come costruire passo dopo passo un circuito con due galleggianti che ferma automaticamente la pompa a serbatoio pieno. Oltre ai codici per Arduino Uno, ESP32 e Raspberry Pi Pico, capirai in quali casi il galleggiante è meglio dei sensori a sonda conduttiva, senza contatto o a ultrasuoni.

Cos'è un sensore di livello a galleggiante e come funziona?
Nel corpo di plastica cavo al centro del sensore c'è un piccolo tubo di vetro riempito di gas inerte. Dentro il tubo ci sono due lamelle di metallo ferromagnetico molto vicine tra loro: è il contatto reed. Nel galleggiante, che scorre libero sul corpo, è inserito un magnete ad anello. Quando l'acqua sale il galleggiante sale e scorre lungo il corpo; quando il magnete arriva all'altezza del contatto reed il campo magnetico magnetizza le due lamelle, che si attraggono e chiudono il circuito. Quando il magnete si allontana, l'elasticità delle lamelle le separa e il circuito si riapre.
Questa struttura ha due grandi vantaggi. Il primo: il contatto elettrico è completamente chiuso nel vetro, nessun metallo tocca l'acqua, quindi non ci sono ossidazione per elettrolisi o sporco come nei sensori a sonda conduttiva. Il secondo: l'uscita è puramente digitale, aperto o chiuso. Non servono lettura analogica, calibrazione o librerie. In compenso il galleggiante conosce un solo punto: non ti dice se l'acqua è a 12 cm o a 18 cm, risponde solo alla domanda "il livello è sopra o sotto questa linea?". Lo stesso principio si usa nei sensori per porte e finestre; per approfondire leggi l'articolo sul relè reed.
| Caratteristica | Valore tipico (piccolo modello verticale) |
|---|---|
| Elemento sensibile | Contatto reed + magnete ad anello nel galleggiante |
| Uscita | Contatto a secco (aperto / chiuso), 2 fili, senza polarità |
| Tipo di contatto | NO o NC (si cambia montando il galleggiante al contrario) |
| Potenza massima di commutazione | 10 W |
| Tensione massima di commutazione | 100 V DC |
| Corrente massima di commutazione | 0,5 A |
| Resistenza di contatto | 100 mΩ o meno |
| Materiale di corpo e galleggiante | PP (polipropilene) |
| Temperatura di esercizio | −10 … +85 °C |
| Montaggio | Corpo filettato con dado e guarnizione sul fondo o sul coperchio del serbatoio |
Montaggio NO e NC: girare il galleggiante
La maggior parte dei sensori esce dalla scatola in versione NO (normalmente aperto): senza acqua il galleggiante sta in basso sulla rondella di arresto e il contatto è aperto; quando l'acqua solleva il galleggiante il contatto si chiude. Il magnete dentro il galleggiante non è al centro ma vicino a un'estremità. Se togli l'anello di fermo (seeger) all'estremità del corpo e rimonti il galleggiante capovolto, cambia la posizione del magnete rispetto al reed e il sensore diventa NC (normalmente chiuso): chiuso senza acqua, aperto quando arriva l'acqua. Attenzione a un altro punto: anche montare il sensore dal fondo verso l'alto o dal coperchio verso il basso cambia la posizione di riposo del galleggiante. Quindi, qualunque modello tu abbia, prima di montarlo metti il multimetro in continuità (cicalino), alza e abbassa il galleggiante a mano e osserva il comportamento reale.
| Montaggio | Senza acqua (galleggiante in basso) | Con acqua (galleggiante in alto) | Pin con INPUT_PULLUP |
|---|---|---|---|
| NO (normalmente aperto) | Contatto aperto | Contatto chiuso | HIGH all'asciutto, LOW con acqua |
| NC (normalmente chiuso) | Contatto chiuso | Contatto aperto | LOW all'asciutto, HIGH con acqua |
Collegamenti: pin di Arduino Uno, ESP32 e Pico
Tra i due fili del galleggiante non c'è differenza di polarità. Basta collegare un filo a GND, l'altro a un pin digitale e attivare la resistenza di pull-up interna del pin; non serve nessuna resistenza esterna. Con il contatto aperto la pull-up porta il pin a 5 V (3,3 V su ESP32 e Pico) e leggi HIGH; quando il contatto si chiude il pin va direttamente a GND e leggi LOW. La pull-up interna dell'Uno è di 20–50 kΩ: con contatto chiuso la corrente è 5 V / 30 kΩ ≈ 0,17 mA, un valore minuscolo che non stressa affatto il reed. I dettagli sulla logica pull-up sono nell'articolo Resistenze pull-up e pull-down. La tabella seguente mostra i pin usati in tutti i codici dell'articolo:
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Galleggiante alto (serbatoio pieno) | D2 | GPIO 27 | GP2 |
| Galleggiante basso (serbatoio vuoto) | D3 | GPIO 26 | GP3 |
| Altri fili dei galleggianti | GND | GND | GND |
| IN del modulo relè | D7 | GPIO 23 | GP15 |
| Buzzer attivo (+) | D8 | GPIO 25 | GP16 |
| VCC del modulo relè | 5V | VIN (5 V) | VBUS (5 V) |
Passo dopo passo: la prima lettura del galleggiante
- Metti il multimetro in continuità, appoggia i puntali ai due fili del galleggiante e fai scorrere il galleggiante su e giù a mano per capire se lavora NO o NC.
- Collega un filo al pin GND di Arduino e l'altro al pin D2. Se i fili sono sottili, salda le estremità a un cavo jumper o usa una morsettiera.
- Carica il codice qui sotto: imposta il pin come INPUT_PULLUP, quindi non serve nessuna resistenza aggiuntiva.
- Apri il Serial Monitor a 9600 baud.
- Spingi il galleggiante verso l'alto con un dito: nel montaggio NO il LED integrato sul D13 deve accendersi e sullo schermo deve apparire il messaggio "YUKSEK". Quando lo lasci il LED deve spegnersi e deve arrivare il messaggio "DUSUK".
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 parte più importante del codice è la sezione di debounce (filtro delle oscillazioni). In un serbatoio l'acqua non è mai del tutto ferma: mentre la pompa lavora, quando si apre un rubinetto o si riempie, la superficie ondeggia e il galleggiante può aprirsi e chiudersi più volte al secondo vicino alla soglia. Il codice azzera il timer a ogni cambio del valore del pin e accetta il nuovo valore solo se resta invariato per 300 ms. È la stessa idea del debounce dei pulsanti, solo con un tempo più lungo. In un serbatoio molto mosso puoi portare il tempo a 1–2 secondi. Poiché il tempo è gestito con millis(), il loop non si ferma mai; il motivo è spiegato nell'articolo sulla differenza tra millis e delay.
Il circuito che ferma la pompa a serbatoio pieno
Si può controllare una pompa anche con un solo galleggiante, ma c'è un problema: quando il livello è proprio sulla soglia, la pompa si accende e si spegne ogni pochi secondi, e questo logora sia la pompa sia il relè. La soluzione è l'isteresi, cioè usare due soglie separate. Metti un galleggiante nella parte bassa del serbatoio e un altro in quella alta. Quando l'acqua scende sotto il galleggiante basso la pompa parte, quando raggiunge quello alto si ferma; nella zona intermedia la pompa mantiene il suo stato. Con 15 cm tra i due galleggianti e una pompa che eroga 3 litri al minuto, in un serbatoio con base 30×40 cm (1200 cm²) questa zona vale 18 litri e la pompa lavora ogni volta circa 6 minuti di fila. Il codice fa anche due controlli di sicurezza: se il galleggiante alto risulta in acqua ma quello basso all'asciutto, è fisicamente impossibile, quindi c'è un guasto a un filo o a un sensore; se la pompa lavora più del previsto, la sorgente potrebbe essersi esaurita o un tubo essersi staccato. In entrambi i casi la pompa si ferma e il buzzer suona.
- 2 sensori a galleggiante: per la soglia bassa e quella alta; nel montaggio NO entrambi danno LOW in acqua.
- Modulo relè a 1 canale: commuta l'alimentazione della pompa. La maggior parte dei moduli si attiva quando il pin IN va LOW (attivo basso); nel codice lo imposti con la costante RELAY_ACTIVE_LOW. Dettagli nell'articolo sul modulo relè.
- Pompa e alimentatore separato: per una piccola pompa come una mini sommergibile da 6 V usa 4 pile AA o un alimentatore da 6 V; non prelevare la corrente della pompa dal pin 5V di Arduino. Per scegliere la pompa dai un'occhiata all'articolo sulla mini pompa dell'acqua.
- GND comune: se usi un modulo relè, i GND di Arduino e del modulo si uniscono, mentre il circuito della pompa resta separato tramite il contatto del relè. Se usi un MOSFET, anche il negativo dell'alimentazione della pompa va collegato al GND di Arduino e in parallelo alla pompa, in senso inverso, va aggiunto un diodo 1N4007.
- Buzzer attivo: in caso di guasto ti avvisa suonando a intermittenza.
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}| Sezione di codice | Compito |
|---|---|
| updateSensor(i) | Legge ogni galleggiante separatamente; aggiorna wet[i] quando il valore resta stabile per 500 ms. |
| wet[0] / wet[1] | Indica se il galleggiante alto e quello basso sono in acqua (true = in acqua). |
| !pumpOn && !wet[1] | L'acqua è scesa sotto la soglia bassa: avvia la pompa. |
| pumpOn && wet[0] | L'acqua ha raggiunto la soglia alta: ferma la pompa. |
| wet[0] && !wet[1] | Alto in acqua, basso asciutto: lettura incoerente, cioè guasto a un filo o a un sensore. |
| MAX_RUN_MS | Se la pompa lavora più di 10 minuti scatta la protezione contro il funzionamento a secco. |
| stopWithFault() | Ferma la pompa e blocca il guasto; per cancellarlo risolvi il problema e resetta la scheda. |
| RELAY_ACTIVE_LOW | Regola il livello di uscita a seconda che il modulo relè si attivi con LOW o con HIGH. |
Lettura del galleggiante e controllo pompa con ESP32
Su ESP32 il codice è quasi identico; cambiano solo i pin e la velocità seriale. In questa versione c'è una costante WET_LEVEL per ogni galleggiante: se monti un sensore NC ti basta mettere il valore corrispondente a HIGH, il resto della logica non cambia. Il codice inoltre scrive lo stato del livello sulla seriale ogni 5 secondi; in futuro puoi trasformare questa riga in un codice che invia una notifica allo smartphone via Wi-Fi. Attenzione nella scelta dei pin: i GPIO 34, 35, 36 e 39 dell'ESP32 sono solo ingressi e non hanno resistenze di pull-up interne; se colleghi il galleggiante a questi pin devi aggiungere una pull-up esterna da 10 kΩ. Conviene anche evitare i pin di avvio (strapping) come GPIO 0, 2, 12 e 15: se all'avvio il galleggiante è chiuso, la scheda può entrare in modalità di programmazione o non avviarsi affatto. Il codice compila sia con ESP32 Arduino core 2.x sia 3.x. Se sei alle prime armi con l'ESP32, dai prima un'occhiata a Cos'è ESP32?.
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}Codice MicroPython con Raspberry Pi Pico
Anche sul Pico costruiamo la stessa logica con MicroPython. Il parametro Pin.PULL_UP attiva la resistenza di pull-up interna ed è disponibile su tutti i pin GP del Pico. Per misurare il tempo si usano time.ticks_ms() e time.ticks_diff(); ticks_diff calcola la differenza corretta anche quando il contatore va in overflow. Poiché le uscite del Pico sono a 3,3 V, fai attenzione alla scelta del relè: alcuni moduli con optoisolatore alimentati a 5 V potrebbero non rilasciare del tutto con un livello HIGH di 3,3 V. Un modulo relè con attivazione a 3,3 V o un MOSFET a livello logico è una scelta più sicura. Se salvi il codice con il nome main.py, il Pico lo esegue automaticamente a ogni avvio. Se sei nuovo di MicroPython, l'articolo Cos'è Raspberry Pi Pico? spiega l'installazione.
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)Differenze tra il galleggiante e altri sensori di livello dell'acqua
| Sensore | Uscita | Pro | Contro |
|---|---|---|---|
| Galleggiante (float switch) | Digitale, un solo punto | Economico, nessuna libreria, nessun metallo a contatto con l'acqua, lunga durata | Dà solo l'informazione di soglia; sporco e alghe possono bloccare il galleggiante |
| Sensore di livello a sonda conduttiva | Analogico | Molto economico, dà un valore graduale in base alla superficie bagnata | Si consuma in fretta per elettrolisi, non adatto a restare sempre in acqua |
| Sensore senza contatto XKC-Y25 | Digitale, un solo punto | Si incolla all'esterno del serbatoio, non serve forare | Non funziona con pareti spesse o metalliche, più costoso |
| Ultrasuoni (HC-SR04, JSN-SR04T) | Distanza continua | Misura il livello in centimetri, nessun contatto con il liquido | Disturbato da schiuma e vapore, ha una zona cieca; l'HC-SR04 non è impermeabile |
La regola di scelta è semplice: se vuoi una risposta affidabile alla domanda "il serbatoio è pieno o vuoto?", il galleggiante è la scelta migliore. Se vuoi mostrare il livello in percentuale, usa un sensore a ultrasuoni; i dettagli sono nel confronto tra sensori di distanza. Se non puoi forare il serbatoio, il sensore senza contatto XKC-Y25 fa al caso tuo. I moduli a sonda considerali solo per prove o misure di breve durata; nell'articolo sul sensore di livello dell'acqua trovi come allungarne la vita. Nei sistemi seri spesso si usano entrambi: il sensore a ultrasuoni mostra il livello e il galleggiante resta in attesa come protezione di riserva contro il troppopieno.
Idee di progetto con il sensore a galleggiante
- Riempimento automatico del serbatoio: riempi da solo la cisterna sul tetto o in giardino con due galleggianti e una pompa.
- Vaso intelligente e stazione di irrigazione: un sensore di umidità del terreno decide quando irrigare, mentre il galleggiante protegge la pompa dal funzionamento a secco quando la riserva d'acqua è finita.
- Rabbocco per acquario: aggiungi a poco a poco l'acqua evaporata da una vaschetta separata; un secondo galleggiante in montaggio NC in alto fa da sicurezza contro il troppopieno.
- Allarme per deumidificatore e scarico del condizionatore: quando la vaschetta è piena il buzzer suona o l'alimentazione dell'apparecchio viene tolta con un relè.
- Monitoraggio del serbatoio di una serra: nel tuo progetto di serra intelligente segnala sullo smartphone il livello del serbatoio con l'ESP32.
- Allarme allagamento in cantina: un galleggiante montato vicino al pavimento invia un messaggio con un bot Telegram quando si accumula acqua.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il pin cambia continuamente a caso | INPUT_PULLUP dimenticato, pin flottante (floating) | Imposta pinMode su INPUT_PULLUP o aggiungi una pull-up esterna da 10 kΩ |
| Lo stato è sempre invertito | Il sensore lavora NC o è montato al contrario | Rimonta il galleggiante capovolto o cambia il valore di WET_LEVEL nel codice |
| La pompa si accende e si spegne di continuo sulla soglia | Un solo galleggiante e tempo di filtro breve | Costruisci l'isteresi con due galleggianti, porta il filtro a 1–2 secondi |
| Il galleggiante non reagisce mai | Reed saldato per sovraccarico o tubo di vetro rotto | Fai il test di continuità con il multimetro e commuta sempre il carico con un relè |
| Il galleggiante resta bloccato in alto | Sporco, calcare o alghe accumulati | Pulisci regolarmente corpo e galleggiante, metti un filtro all'ingresso dell'acqua |
| Arduino si resetta quando parte la pompa | La pompa è alimentata dalla stessa fonte, la tensione crolla | Usa un'alimentazione separata per la pompa e collega correttamente i GND |
| L'ESP32 non si avvia o si blocca all'avvio | Il galleggiante è collegato a un pin di strapping | Usa pin sicuri come GPIO 26 e 27 |
Nonostante la struttura economica e semplice, il sensore a galleggiante, unito a un montaggio corretto, lettura con pull-up, filtro software e isteresi, è la base di un'automazione che funziona senza problemi per anni. Ritroverai la stessa logica del contatto reed nei sensori per porte e lo stesso controllo pompa nei sistemi di irrigazione. Nell'app BlueGrays puoi esaminare passo dopo passo i progetti di lettura del relè reed, sensore porta e stazione di irrigazione intelligente con schemi e codici pronti, e adattare il circuito di questo articolo al tuo progetto.
Domande frequenti
Come funziona un sensore a galleggiante?
Dentro il galleggiante c'è un magnete ad anello, nel corpo un contatto reed in tubo di vetro. Quando il livello sale, il galleggiante scorre lungo il corpo e, quando il magnete arriva all'altezza del reed, il contatto si chiude o si apre. Il sensore si comporta quindi come un interruttore azionato dall'acqua e dà un segnale digitale attraverso i suoi due fili.
Il sensore a galleggiante è NO o NC?
Lo stesso sensore si può usare in entrambi i modi. Se togli l'anello di fermo all'estremità del corpo e rimonti il galleggiante capovolto, un sensore NO (normalmente aperto) diventa NC (normalmente chiuso). Poiché anche il verso di montaggio influisce sul comportamento, il modo più sicuro è fare un test di continuità con il multimetro prima di installarlo.
Serve una resistenza per il sensore a galleggiante?
Su Arduino, ESP32 e Pico, se attivi la pull-up interna del pin (INPUT_PULLUP o Pin.PULL_UP) non serve nessuna resistenza aggiuntiva. Se il cavo è più lungo di qualche metro o c'è molto disturbo, una pull-up esterna da 10 kΩ e un condensatore da 100 nF rendono la lettura più stabile. Sui pin 34–39 dell'ESP32 non c'è pull-up interna, quindi lì la resistenza esterna è obbligatoria.
Il sensore a galleggiante può azionare direttamente la pompa?
Il contatto reed dei piccoli galleggianti hobbistici di solito commuta al massimo 10 W e 0,5 A; la corrente di spunto di una pompa supera facilmente questo limite e salda i contatti. Il metodo corretto è collegare il galleggiante al microcontrollore e pilotare la pompa con un modulo relè o un MOSFET. In questo modo puoi aggiungere via software anche la protezione dal funzionamento a secco e dal tempo massimo.
Il sensore a galleggiante funziona con ESP32 e Raspberry Pi Pico?
Sì, poiché il sensore è solo un interruttore la tensione di alimentazione non conta e funziona senza problemi con schede a 3,3 V. Basta collegare un filo a GND e l'altro a un GPIO con la pull-up attiva. Sull'ESP32 evita i pin di strapping e i pin 34–39, che non hanno pull-up interna.
Posso misurare il livello dell'acqua in percentuale con un galleggiante?
Un solo galleggiante rileva un unico punto di soglia. Mettendo tre o quattro galleggianti a diverse altezze del serbatoio puoi ottenere un indicatore di percentuale approssimativo, ma per una misura continua e precisa al centimetro è più adatto un sensore di distanza a ultrasuoni. Una buona soluzione è usare insieme i due: il sensore a ultrasuoni come indicatore di livello e il galleggiante come sicurezza di riserva contro il troppopieno.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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.

Controllo LED ESP32 con pulsante (Push)
Il LED si accende quando il pulsante viene premuto e si spegne quando viene rilasciato. Mostra come vengono utilizzati il pin di ingresso digitale dell'ESP32 e la resistenza di pull-up interna. Grazie alla modalità INPUT_PULLUP, non è necessaria alcuna resistenza esterna.

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.

Lettura di un sensore reed
Ti sei mai chiesto come funziona l'interruttore magnetico degli allarmi per porte e finestre?

Sensore porta con contatto reed
Capisci se la tua porta è aperta o chiusa guardando una luce. Metti un piccolo magnete sulla porta e sul telaio un interruttore che sente i magneti; a porta chiusa stanno vicini e si accende il LED…

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

Lampadina 220V con pulsante (Push)
Finché tieni premuto il pulsante, una vera lampadina da 220 volt resta accesa, e si spegne appena lo lasci.
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

