Componentes · 12 min de lectura

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.

Sensor de nivel de agua con flotador (float switch)
Sensor de nivel con flotador vertical: flotador con imán, cuerpo con contacto reed en su interior, parte roscada para el montaje y dos cables.

¿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ísticaValor típico (modelo vertical pequeño)
Elemento sensorContacto reed + imán en anillo dentro del flotador
SalidaContacto seco (abierto / cerrado), 2 cables, sin polaridad
Tipo de contactoNO o NC (se cambia montando el flotador al revés)
Potencia máxima de conmutación10 W
Tensión máxima de conmutación100 V DC
Corriente máxima de conmutación0,5 A
Resistencia de contacto100 mΩ o menos
Material del cuerpo y el flotadorPP (polipropileno)
Temperatura de trabajo−10 … +85 °C
MontajeCuerpo 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.

MontajeSin agua (flotador abajo)Con agua (flotador arriba)Pin con INPUT_PULLUP
NO (normalmente abierto)Contacto abiertoContacto cerradoHIGH en seco, LOW con agua
NC (normalmente cerrado)Contacto cerradoContacto abiertoLOW en seco, HIGH con agua
En aplicaciones de seguridad como una alarma de desbordamiento, prefiere el montaje NC. En un circuito NC el contacto está cerrado en condiciones normales y el pin lee LOW; si el agua sube, o si se corta un cable o se suelta un conector, el pin pasa a HIGH. Así la avería también se detecta como alarma, y si el sensor queda fuera de servicio sin avisar, la bomba no sigue funcionando como si nada.

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ónArduino UnoESP32Raspberry Pi Pico
Flotador superior (depósito lleno)D2GPIO 27GP2
Flotador inferior (depósito vacío)D3GPIO 26GP3
Otros cables de los flotadoresGNDGNDGND
IN del módulo de reléD7GPIO 23GP15
Zumbador activo (+)D8GPIO 25GP16
VCC del módulo de relé5VVIN (5 V)VBUS (5 V)
No conectes la bomba ni una electroválvula directamente a los cables del flotador. El contacto reed de los modelos pequeños solo puede conmutar como máximo unos 10 W y 0,5 A (los valores varían según el producto, revisa la etiqueta); la corriente de arranque del motor y el arco al abrirse sueldan en poco tiempo las láminas del tubo de vidrio y el sensor marca siempre "lleno" o "vacío". El flotador debe limitarse a dar la señal al microcontrolador, y la carga debe conmutarla un relé o un MOSFET. Tampoco pases nunca la tensión de red de 220 V por el flotador.

Paso a paso: leer el flotador por primera vez

  1. 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.
  2. 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.
  3. Sube el código siguiente; configura el pin como INPUT_PULLUP, así que no necesitas ninguna resistencia adicional.
  4. Abre el Monitor Serie a 9600 baudios.
  5. 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".
C++ (Arduino IDE)
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.
C++ (Arduino IDE)
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ódigoFunció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_MSSi 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_LOWAjusta 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?.

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

MicroPython
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

SensorSalidaVentajasInconvenientes
Flotador (float switch)Digital, un solo puntoBarato, no necesita librería, ningún metal toca el agua, larga vida útilSolo da información de umbral; la suciedad y las algas pueden atascar el flotador
Sensor de nivel de agua con sonda conductivaAnalógicaMuy barato, da un valor gradual según la superficie mojadaSe desgasta rápido por electrólisis, no sirve para permanecer siempre en el agua
Sensor sin contacto XKC-Y25Digital, un solo puntoSe pega por fuera del depósito, no hace falta taladrarNo funciona con paredes gruesas o metálicas, más caro
Ultrasónico (HC-SR04, JSN-SR04T)Distancia continuaMide el nivel en centímetros, no toca el líquidoLe 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íntomaCausa probableSolución
El pin cambia constantemente al azarSe 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á invertidoEl sensor funciona como NC o está montado al revésMonta 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 umbralUn solo flotador y tiempo de filtrado cortoCrea histéresis con dos flotadores y sube el tiempo de filtrado a 1–2 segundos
El flotador no reaccionaEl contacto reed se ha soldado por sobrecarga o el tubo de vidrio está rotoHaz una prueba de continuidad con el multímetro y conmuta siempre la carga con un relé
El flotador se queda atascado arribaAcumulación de suciedad, cal o algasLimpia el cuerpo y el flotador con regularidad y pon un filtro en la entrada de agua
Arduino se reinicia cuando arranca la bombaLa bomba se alimenta de la misma fuente y la tensión caeUsa una fuente aparte para la bomba y conecta bien el GND
El ESP32 no arranca o se queda colgado al arrancarEl flotador está conectado a un pin strappingUsa pines seguros como GPIO 26 y 27
Si los cables del flotador superan unos pocos metros, añade una resistencia pull-up externa de 10 kΩ junto al pin y un condensador de 100 nF entre el pin y GND. La constante de tiempo de este filtro RC es 10 kΩ × 100 nF = 1 ms; filtra el ruido eléctrico sin ralentizar de forma apreciable la respuesta del flotador. Puedes probar otros valores con la calculadora de constante de tiempo RC. Aísla también los empalmes de los cables con termorretráctil para protegerlos de la humedad.

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.

Ver todos los proyectos
Encender un LED con pulsador (Push)
AR-9Principiante

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.

4.8(114)
253
Control de LED con pulsador en ESP32 (Push)
ES-2Principiante

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.

4.6(36)
57
Uso del zumbador
AR-13Principiante

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.

4.7(92)
170
Lectura de un interruptor reed
AR-37Principiante

Lectura de un interruptor reed

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

4.5(22)
29
Sensor de puerta con interruptor reed
AR-38Principiante
Premium

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…

4.7(34)
44
Estación de riego inteligente
AR-83Avanzado
Premium

Estación de riego inteligente

Un jardinero que riega solo tus plantas para que no se sequen mientras estás de vacaciones.

5.0(42)
57
Bombilla 220V con Pulsador (Push)
AR-19Avanzado
Premium

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.

4.4(30)
38