Sensor de nivel con flotador Arduino: control de bomba
¿Cómo conectar un sensor de nivel con flotador a Arduino? Montaje NO/NC, pull-up y código para Uno, ESP32 y Pico que apaga la bomba al llenar el depósito.
El sensor de flotador (float switch) es la forma más sencilla y fiable de saber con Arduino si un depósito de agua, un acuario o un tanque de riego está lleno o vacío. Por dentro tiene un flotador con imán y un contacto reed en un tubo de vidrio: cuando el nivel del agua empuja el flotador hacia arriba, el contacto se cierra, y cuando el agua baja, se abre. Para la electrónica, el sensor es igual que un pulsador accionado por el agua: conectas uno de sus cables a GND, el otro a un pin digital y lees el pin con INPUT_PULLUP.
En este artículo verás cómo es el interior del flotador, la diferencia entre el montaje NO y NC, cómo filtrar por software las oscilaciones del agua y cómo montar paso a paso un circuito con dos flotadores que apaga la bomba cuando el depósito se llena. Además de los códigos para Arduino Uno, ESP32 y Raspberry Pi Pico, verás en qué casos el flotador es mejor que los sensores de nivel de sonda conductiva, sin contacto y ultrasónicos.

¿Qué es un sensor de nivel con flotador y cómo funciona?
Dentro del cuerpo hueco de plástico del centro del sensor hay un pequeño tubo de vidrio lleno de gas inerte. Dentro del tubo hay dos láminas metálicas ferromagnéticas muy próximas entre sí: es el contacto reed (contacto de lengüeta). En el flotador, que se desliza libremente sobre el cuerpo, hay un imán en forma de anillo. Al subir el agua, el flotador asciende y se desliza por el cuerpo; cuando el imán queda a la altura del contacto reed, el campo magnético imanta las dos láminas, se atraen y el circuito se cierra. Cuando el imán se aleja, la elasticidad de las láminas las separa y el circuito vuelve a abrirse.
Esta estructura tiene dos grandes ventajas. La primera: el contacto eléctrico está dentro de un tubo de vidrio totalmente sellado; ningún metal toca el agua, así que no hay problemas de oxidación por electrólisis ni de suciedad como en los sensores de sonda conductiva. La segunda: la salida es totalmente digital, abierta o cerrada. No necesitas lectura analógica, calibración ni librerías. A cambio, el flotador solo conoce un único punto: no puede decirte si el agua está a 12 cm o a 18 cm, solo responde a "¿el nivel está por encima o por debajo de esta línea?". El mismo principio se usa en los sensores de puertas y ventanas; para más detalles consulta el artículo Relé Reed.
| Característica | Valor típico (modelo vertical pequeño) |
|---|---|
| Elemento sensor | Contacto reed + imán en anillo dentro del flotador |
| Salida | Contacto seco (abierto / cerrado), 2 cables, sin polaridad |
| Tipo de contacto | NO o NC (se cambia montando el flotador al revés) |
| Potencia máxima de conmutación | 10 W |
| Tensión máxima de conmutación | 100 V DC |
| Corriente máxima de conmutación | 0,5 A |
| Resistencia de contacto | 100 mΩ o menos |
| Material del cuerpo y el flotador | PP (polipropileno) |
| Temperatura de trabajo | −10 … +85 °C |
| Montaje | Cuerpo roscado, con tuerca y junta, en el fondo o en la tapa del depósito |
Montaje NO y NC: dar la vuelta al flotador
La mayoría de los sensores salen de la caja funcionando como NO (normalmente abierto): sin agua, el flotador descansa sobre la arandela de tope de abajo y el contacto está abierto; cuando el agua levanta el flotador, el contacto se cierra. El imán del flotador no está justo en el centro, sino cerca de un extremo. Por eso, si sacas el anillo de retención (seguro) del extremo del cuerpo y vuelves a colocar el flotador al revés, cambia la posición del imán respecto al contacto reed y el sensor pasa a ser NC (normalmente cerrado): cerrado sin agua, abierto con agua. Hay otro detalle: montar el sensor desde el fondo hacia arriba o colgado desde la tapa hacia abajo también cambia la posición de reposo del flotador. Por eso, sea cual sea el modelo, antes de instalarlo pon el multímetro en continuidad (pitido), sube y baja el flotador con la mano y comprueba el comportamiento real.
| Montaje | Sin agua (flotador abajo) | Con agua (flotador arriba) | Pin con INPUT_PULLUP |
|---|---|---|---|
| NO (normalmente abierto) | Contacto abierto | Contacto cerrado | HIGH en seco, LOW con agua |
| NC (normalmente cerrado) | Contacto cerrado | Contacto abierto | LOW en seco, HIGH con agua |
Conexión: pines de Arduino Uno, ESP32 y Pico
Los dos cables del flotador no tienen polaridad. Basta con conectar un cable a GND, el otro a un pin digital y activar la resistencia pull-up interna del pin; no hace falta resistencia externa. Con el contacto abierto, la pull-up lleva el pin a 5 V (3,3 V en ESP32 y Pico) y se lee HIGH; cuando el contacto se cierra, el pin queda conectado directamente a GND y se lee LOW. La pull-up interna del Uno es de 20–50 kΩ; la corriente con el contacto cerrado es de unos 5 V / 30 kΩ ≈ 0,17 mA, un valor minúsculo que no castiga en absoluto al contacto reed. Los detalles de la lógica pull-up están en el artículo Resistencia pull-up y pull-down. La siguiente tabla muestra los pines usados en todos los códigos del resto del artículo:
| Conexión | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Flotador superior (depósito lleno) | D2 | GPIO 27 | GP2 |
| Flotador inferior (depósito vacío) | D3 | GPIO 26 | GP3 |
| Otros cables de los flotadores | GND | GND | GND |
| IN del módulo de relé | D7 | GPIO 23 | GP15 |
| Zumbador activo (+) | D8 | GPIO 25 | GP16 |
| VCC del módulo de relé | 5V | VIN (5 V) | VBUS (5 V) |
Paso a paso: leer el flotador por primera vez
- Pon el multímetro en continuidad, toca con las puntas los dos cables del flotador y desliza el flotador arriba y abajo con la mano para saber si funciona como NO o NC.
- Conecta uno de los cables al pin GND de Arduino y el otro al pin D2. Si los cables son finos, suelda los extremos a cables jumper o usa un bornero.
- Sube el código siguiente; configura el pin como INPUT_PULLUP, así que no necesitas ninguna resistencia adicional.
- Abre el Monitor Serie a 9600 baudios.
- Empuja el flotador hacia arriba con el dedo: en montaje NO debe encenderse el LED interno del pin D13 y aparecer el mensaje "YUKSEK" en pantalla. Al soltarlo, el LED debe apagarse y llegar el mensaje "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 más importante del código es la sección de debounce (filtrado de oscilaciones). En un depósito el agua nunca está completamente quieta: con la bomba en marcha, al abrir un grifo o al llenar, la superficie se agita y el flotador puede abrirse y cerrarse varias veces por segundo en el punto umbral. El código reinicia el temporizador cada vez que cambia el valor del pin y acepta el nuevo valor solo si permanece sin cambiar durante 300 ms. Es la misma idea del debounce de los pulsadores, solo que con un tiempo más largo. En un depósito con mucho oleaje puedes subir el tiempo a 1–2 segundos. Como la temporización se hace con millis(), el loop nunca se bloquea; puedes leer el motivo en el artículo diferencia entre millis y delay.
Circuito que apaga la bomba cuando el depósito se llena
También se puede controlar la bomba con un solo flotador, pero hay un problema: cuando el nivel del agua está justo en el umbral, la bomba se enciende y se apaga cada pocos segundos. Eso desgasta tanto la bomba como el relé. La solución es la histéresis, es decir, usar dos umbrales distintos. Colocas un flotador en la parte baja del depósito y otro en la parte alta. Cuando el agua cae por debajo del flotador inferior, la bomba arranca; cuando alcanza el flotador superior, se detiene; en la zona intermedia la bomba mantiene su estado. Si hay 15 cm entre los dos flotadores y la bomba impulsa 3 litros por minuto, en un depósito de base 30×40 cm (1200 cm²) esa zona equivale a 18 litros y la bomba funciona de forma continua unos 6 minutos cada vez. El código además realiza dos comprobaciones de seguridad: si el flotador superior aparece en el agua pero el inferior en seco, es físicamente imposible, así que hay un fallo de cable o de sensor; y si la bomba funciona más tiempo del esperado, la fuente puede haberse secado o la manguera haberse soltado. En ambos casos la bomba se detiene y suena el zumbador.
- 2 sensores de flotador: Para el umbral inferior y el superior; en montaje NO, ambos dan LOW dentro del agua.
- Módulo de relé de 1 canal: Conmuta la alimentación de la bomba. La mayoría de los módulos se activan cuando el pin IN está en LOW (activo en bajo); en el código lo ajustas con la constante RELAY_ACTIVE_LOW. Los detalles están en el artículo Módulo de relé.
- Bomba y fuente de alimentación independiente: Para una bomba pequeña, como una minibomba sumergible de 6 V, usa 4 pilas AA o un adaptador de 6 V; no tomes la corriente de la bomba del pin 5V de Arduino. Para elegir la bomba echa un vistazo al artículo Minibomba de agua.
- GND común: Si usas un módulo de relé, los GND de Arduino y del módulo se unen, mientras que el circuito de la bomba queda separado a través del contacto del relé. Si usas un MOSFET, el negativo de la fuente de la bomba también debe conectarse al GND de Arduino y debe añadirse un diodo 1N4007 en paralelo con la bomba, en sentido inverso.
- Zumbador activo: Te avisa pitando de forma intermitente cuando hay una avería.
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}| Sección del código | Función |
|---|---|
| updateSensor(i) | Lee cada flotador por separado; actualiza el estado wet[i] cuando el valor se mantiene estable 500 ms. |
| wet[0] / wet[1] | Si el flotador superior y el inferior están en el agua (true = en el agua). |
| !pumpOn && !wet[1] | El agua bajó del umbral inferior: arrancar la bomba. |
| pumpOn && wet[0] | El agua llegó al umbral superior: detener la bomba. |
| wet[0] && !wet[1] | Superior en el agua, inferior en seco: lectura incoherente, es decir, fallo de cable o de sensor. |
| MAX_RUN_MS | Si la bomba funciona más de 10 minutos, entra la protección contra funcionamiento en seco. |
| stopWithFault() | Detiene la bomba y bloquea el fallo; para borrarlo, soluciona el problema y reinicia la placa. |
| RELAY_ACTIVE_LOW | Ajusta el nivel de salida según el módulo de relé se active con LOW o con HIGH. |
Lectura del flotador y control de la bomba con ESP32
En el ESP32 el código es casi igual; solo cambian los pines y la velocidad serie. En esta versión hay una constante WET_LEVEL para cada flotador: si montas un sensor como NC, basta con poner el valor correspondiente en HIGH y el resto de la lógica no cambia. El código además escribe el estado del nivel en el puerto serie cada 5 segundos; más adelante puedes convertir esa línea en un código que envíe notificaciones al móvil por Wi-Fi. Atención al elegir pines: los GPIO 34, 35, 36 y 39 del ESP32 son solo de entrada y no tienen resistencias pull-up internas; si conectas el flotador a esos pines, debes añadir una pull-up externa de 10 kΩ. También conviene evitar los pines de arranque (strapping) como GPIO 0, 2, 12 y 15; si el flotador está cerrado durante el arranque, la placa puede entrar en modo de programación o no arrancar. El código compila con el core de Arduino para ESP32 2.x y 3.x. Si estás empezando con el ESP32, echa primero un vistazo al artículo ¿Qué es el 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}Raspberry Pi Pico: código MicroPython
En la Pico montamos la misma lógica con MicroPython. El parámetro Pin.PULL_UP activa la resistencia pull-up interna y se puede usar en todos los pines GP de la Pico. Para medir el tiempo se usan time.ticks_ms() y time.ticks_diff(); ticks_diff calcula bien la diferencia incluso si el contador se desborda. Como las salidas de la Pico son de 3,3 V, ten cuidado al elegir el relé: algunos módulos con optoacoplador alimentados a 5 V pueden no soltar del todo con el nivel HIGH de 3,3 V. Usar un módulo de relé con disparo a 3,3 V o un MOSFET de nivel lógico es más seguro. Si guardas el código con el nombre main.py, la Pico lo ejecuta automáticamente en cada arranque. Si eres nuevo en MicroPython, el artículo ¿Qué es la Raspberry Pi Pico? explica la instalación.
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)Diferencias entre el flotador y otros sensores de nivel de agua
| Sensor | Salida | Ventajas | Inconvenientes |
|---|---|---|---|
| Flotador (float switch) | Digital, un solo punto | Barato, no necesita librería, ningún metal toca el agua, larga vida útil | Solo da información de umbral; la suciedad y las algas pueden atascar el flotador |
| Sensor de nivel de agua con sonda conductiva | Analógica | Muy barato, da un valor gradual según la superficie mojada | Se desgasta rápido por electrólisis, no sirve para permanecer siempre en el agua |
| Sensor sin contacto XKC-Y25 | Digital, un solo punto | Se pega por fuera del depósito, no hace falta taladrar | No funciona con paredes gruesas o metálicas, más caro |
| Ultrasónico (HC-SR04, JSN-SR04T) | Distancia continua | Mide el nivel en centímetros, no toca el líquido | Le afectan la espuma y el vapor, tiene zona ciega; el HC-SR04 no es impermeable |
La regla de elección es sencilla: si quieres una respuesta fiable a "¿se llenó o se vació el depósito?", el flotador es la mejor opción. Si quieres mostrar el llenado en porcentaje, usa un sensor ultrasónico; los detalles están en el artículo Comparativa de sensores de distancia. Si no puedes taladrar el depósito, el sensor sin contacto XKC-Y25 cumple su función. Los módulos de sonda considéralos solo para pruebas o mediciones de corta duración; en el artículo Sensor de nivel de agua se explican las formas de alargar la vida de ese módulo. En sistemas serios suelen usarse los dos juntos: el sensor ultrasónico muestra el nivel y el flotador queda como protección de reserva contra desbordamientos.
Ideas de proyectos con el sensor de flotador
- Llenado automático de depósitos: Llena por sí solo el depósito de agua del tejado o del jardín con dos flotadores y una bomba.
- Maceta inteligente y estación de riego: Que un sensor de humedad del suelo decida cuándo regar, y que el flotador proteja la bomba del funcionamiento en seco cuando el depósito se vacíe.
- Rellenador de nivel para acuario: Añade poco a poco el agua evaporada desde un depósito aparte; un segundo flotador con montaje NC en la parte superior sirve de seguridad contra desbordamientos.
- Alarma de drenaje de deshumidificador y aire acondicionado: Que suene el zumbador o que un relé corte la alimentación del aparato cuando se llene el recipiente de agua.
- Monitorización del depósito de agua de un invernadero: En tu proyecto de invernadero inteligente, avisa al móvil del nivel del depósito con un ESP32.
- Aviso de inundación en el sótano: Un flotador montado cerca del suelo que envíe un mensaje por un bot de Telegram cuando se acumule agua.
Errores comunes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| El pin cambia constantemente al azar | Se olvidó INPUT_PULLUP, el pin está flotante (floating) | Pon pinMode en INPUT_PULLUP o añade una pull-up externa de 10 kΩ |
| El estado siempre está invertido | El sensor funciona como NC o está montado al revés | Monta el flotador al revés o cambia el valor de WET_LEVEL en el código |
| La bomba se enciende y apaga continuamente en el umbral | Un solo flotador y tiempo de filtrado corto | Crea histéresis con dos flotadores y sube el tiempo de filtrado a 1–2 segundos |
| El flotador no reacciona | El contacto reed se ha soldado por sobrecarga o el tubo de vidrio está roto | Haz una prueba de continuidad con el multímetro y conmuta siempre la carga con un relé |
| El flotador se queda atascado arriba | Acumulación de suciedad, cal o algas | Limpia el cuerpo y el flotador con regularidad y pon un filtro en la entrada de agua |
| Arduino se reinicia cuando arranca la bomba | La bomba se alimenta de la misma fuente y la tensión cae | Usa una fuente aparte para la bomba y conecta bien el GND |
| El ESP32 no arranca o se queda colgado al arrancar | El flotador está conectado a un pin strapping | Usa pines seguros como GPIO 26 y 27 |
A pesar de su estructura barata y sencilla, el sensor de flotador, combinado con un montaje correcto, lectura con pull-up, filtro por software e histéresis, es la base de una automatización que funciona sin problemas durante años. La misma lógica del contacto reed la verás en los sensores de puertas, y el mismo control de bomba en los sistemas de riego. En la aplicación BlueGrays puedes revisar paso a paso, con esquemas de circuito y códigos listos, los proyectos de lectura de relé reed, sensor de puerta y estación de riego inteligente, y adaptar el circuito de este artículo a tu propio proyecto.
Preguntas frecuentes
¿Cómo funciona un sensor de flotador?
Dentro del flotador hay un imán en forma de anillo y, dentro del cuerpo, un contacto reed con tubo de vidrio. Al subir el nivel del agua, el flotador se desliza por el cuerpo y, cuando el imán queda a la altura del contacto reed, este se cierra o se abre. Así el sensor se comporta como un interruptor accionado por el agua y entrega una señal digital por sus dos cables.
¿El sensor de flotador es NO o NC?
El mismo sensor puede usarse de las dos maneras. Si quitas el anillo de retención del extremo del cuerpo y montas el flotador al revés, un sensor NO (normalmente abierto) pasa a ser NC (normalmente cerrado). Como la orientación del montaje también afecta al comportamiento, lo más seguro es hacer una prueba de continuidad con el multímetro antes de instalarlo.
¿Hace falta una resistencia para el sensor de flotador?
En Arduino, ESP32 y Pico no hace falta ninguna resistencia adicional si activas la pull-up interna del pin (INPUT_PULLUP o Pin.PULL_UP). Si el cable es más largo que unos metros o hay interferencias, una pull-up externa de 10 kΩ y un condensador de 100 nF hacen la lectura más estable. En los pines 34–39 del ESP32 no hay pull-up interna, por lo que en ellos la resistencia externa es obligatoria.
¿Puede un sensor de flotador accionar la bomba directamente?
El contacto reed de los flotadores pequeños de uso hobby suele poder conmutar como máximo 10 W y 0,5 A; la corriente de arranque de una bomba supera fácilmente ese límite y suelda los contactos. El método correcto es conectar el flotador al microcontrolador y accionar la bomba mediante un módulo de relé o un MOSFET. Así además puedes añadir por software la protección contra funcionamiento en seco y por tiempo.
¿Funciona el sensor de flotador con ESP32 y Raspberry Pi Pico?
Sí, como el sensor es solo un interruptor, la tensión de alimentación no importa y funciona sin problemas con placas de 3,3 V. Basta con conectar un cable a GND y el otro a un GPIO con la pull-up activada. En el ESP32 evita los pines strapping y los pines 34–39, que no tienen pull-up interna.
¿Puedo medir el nivel de agua en porcentaje con un flotador?
Un solo flotador detecta solamente un punto umbral. Colocando tres o cuatro flotadores a distintas alturas del depósito puedes hacer un indicador de porcentaje aproximado, pero para una medición continua y con precisión de centímetros es más adecuado un sensor de distancia ultrasónico. Una buena solución es usar juntos el sensor ultrasónico como indicador de nivel y el flotador como seguridad de reserva contra desbordamientos.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Encender un LED con pulsador (Push)
Como un timbre: la luz se enciende mientras pulsas y se apaga cuando sueltas. El Arduino escucha el botón todo el rato; mientras está pulsado enciende el LED, y en cuanto levantas el dedo lo apaga.

Control de LED con pulsador en ESP32 (Push)
El LED se enciende cuando se pulsa el botón y se apaga cuando se suelta. Muestra cómo se utiliza el pin de entrada digital del ESP32 y la resistencia pull-up interna. Gracias al modo INPUT_PULLUP, no se necesita ninguna resistencia externa.

Uso del zumbador
¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

Lectura de un interruptor reed
¿Alguna vez te has preguntado cómo funciona el interruptor magnético de las alarmas de puertas y ventanas?

Sensor de puerta con interruptor reed
Sabe si tu puerta está abierta o cerrada con solo mirar una luz. Pones un pequeño imán en la puerta y en el marco un interruptor que nota los imanes; con la puerta cerrada quedan juntos y se enciende…

Estación de riego inteligente
Un jardinero que riega solo tus plantas para que no se sequen mientras estás de vacaciones.

Bombilla 220V con Pulsador (Push)
Mientras mantienes pulsado el botón, una bombilla real de 220 voltios se queda encendida, y se apaga en cuanto lo sueltas.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

