Monitor inteligente de nivel de agua con ESP32: OLED, HC-SR04 y EEPROM
Construye tu propio monitor inteligente de nivel de agua con ESP32: OLED, HC-SR04 y EEPROM
Proyecto DIY sin WiFi y sin ESP-NOW: ajusta la altura del tanque con un potenciómetro, guarda la configuración con un botón y visualiza el nivel de agua en tiempo real con una pantalla OLED. Un LED te avisa cuando queda poca agua.
Transparencia: este artículo puede contener enlaces de afiliado. Si compras a través de ellos, podría recibir una comisión sin costo adicional para ti.
¿Cómo funciona?
El sensor ultrasónico se instala orientado verticalmente hacia la superficie del agua, desde la parte superior del tanque. El sensor mide la distancia d hasta el agua y el sistema conoce la altura H desde la cara del sensor hasta el fondo del tanque. Con esos datos calcula el porcentaje de llenado.
Nivel (%) = 100 × (H − d) / H. El resultado se limita entre 0 y 100 %.
Ejemplo: si H = 100 cm y el sensor mide d = 35 cm, el tanque está aproximadamente al 65 % de su altura útil. Para un tanque de paredes verticales y sección constante, ese porcentaje también aproxima el porcentaje de volumen; en tanques irregulares no equivale directamente al volumen.
Características del proyecto
- Microcontrolador ESP32 DevKit, sin comunicación inalámbrica.
- Sensor de distancia HC-SR04 colocado en la parte superior, fuera del agua.
- Pantalla OLED SSD1306 de 128 × 64 píxeles por I2C.
- Altura configurable desde 10 hasta 250 cm mediante potenciómetro.
- Botón para guardar la altura en EEPROM emulada antes de medir.
- Al reiniciar, lee la altura guardada y la muestra como referencia; requiere confirmar una calibración antes de volver a medir.
- LED intermitente al 20 % o menos de nivel; parpadeo rápido si el sensor falla.
- Pulsación larga de 2 segundos para volver al modo de ajuste.
Lista de materiales
| Material (cantidad) | Qué buscar | Enlace |
|---|---|---|
| ESP32 DevKit | ESP32 DevKit V1 placa de desarrollo | Ver en Temu |
| Sensor ultrasónico HC-SR04 | HC-SR04 sensor ultrasonico de distancia | Ver en Temu |
| Pantalla OLED 0.96 pulgadas | OLED SSD1306 128×64 I2C | Ver en Temu |
| Potenciómetro de 10 kΩ | potenciometro 10K con perilla | Ver en Temu |
| Botón pulsador | pulsador tactil momentaneo | Ver en Temu |
| LED rojo | LED rojo 5mm | Ver en Temu |
| Resistencias | resistencias 1k 2k 220 ohm | Ver en Temu |
| Protoboard | protoboard para prototipos | Ver en Temu |
| Cables Dupont | cables jumper dupont macho hembra | Ver en Temu |
| Fuente/cable USB | alimentacion USB 5V para ESP32 | Ver en Temu |
Se necesitan dos resistencias para el divisor de ECHO (por ejemplo, 1 kΩ y 2 kΩ), además de una resistencia de 220–330 Ω para el LED. Una caja resistente a salpicaduras y soporte del sensor son recomendables para instalaciones reales.
Conexiones del ESP32
| Componente | Pin ESP32 | Nota |
|---|---|---|
| OLED SDA / SCL | GPIO 21 / GPIO 22 | OLED alimentada con 3.3 V si el módulo lo admite |
| HC-SR04 TRIG | GPIO 18 | Disparo ultrasónico |
| HC-SR04 ECHO | GPIO 19 | Obligatorio divisor de tensión para sensor ECHO de 5 V |
| Potenciómetro central | GPIO 34 | Extremos a 3.3 V y GND |
| Botón | GPIO 4 | Otro terminal a GND; INPUT_PULLUP |
| LED | GPIO 23 | Resistencia serie 220–330 Ω y LED hacia GND |
| Alimentación HC-SR04 | 5 V y GND | Comprobar características exactas del módulo |
Protección del pin ECHO: imprescindible
Un HC-SR04 común alimentado a 5 V puede entregar una señal ECHO de 5 V, mientras que el ESP32 utiliza lógica de 3.3 V. Conecta ECHO a una resistencia de 1 kΩ; el otro extremo es el nodo conectado a GPIO 19. Desde ese nodo conecta una resistencia de 2 kΩ a GND. Así, 5 V se reducen aproximadamente a 3.33 V. Todos los GND deben estar conectados. No conectes ECHO de 5 V directamente al ESP32.
HC-SR04 ECHO ── 1 kΩ ──┬── GPIO 19
└── 2 kΩ ── GND
Funcionamiento: calibrar → guardar → medir
- Encender: en OLED aparece el menú CONFIGURAR TANQUE, y si hay un valor en EEPROM se indica la altura guardada anteriormente.
- Ajustar H: gira el potenciómetro hasta la distancia entre la cara emisora del sensor y el fondo del tanque. No es necesariamente la altura exterior del recipiente.
- Guardar e iniciar: presiona y suelta el botón. El sistema escribe la altura en EEPROM emulada y solo entra a medición si
EEPROM.commit()se completó. - Monitorear: cada 600 ms se mide la distancia, se muestra porcentaje, centímetros y barra gráfica en OLED.
- Alerta: LED intermitente si el nivel es ≤ 20 %; parpadeo rápido si no hay medición válida.
- Recalibrar: mantén presionado el botón durante 2 segundos para volver a ajustar H.
Código completo para Arduino IDE
Instala las bibliotecas Adafruit SSD1306 y Adafruit GFX desde el gestor de bibliotecas. Selecciona una placa ESP32 compatible en Arduino IDE. EEPROM.h se incluye en Arduino-ESP32; aquí se usa su emulación sobre memoria flash (no una EEPROM física).
/*
MONITOR DE NIVEL DE AGUA - ESP32 CLASICO
HC-SR04 + OLED SSD1306 + potenciometro + boton + LED
Sin WiFi ni ESP-NOW.
Altura H: distancia desde la cara del sensor hasta el fondo del tanque.
Boton: guardar H en EEPROM emulada y comenzar a medir.
Mantener boton 2 s: volver a calibrar (detiene medicion).
*/
#include <Arduino.h>
#include <Wire.h>
#include <EEPROM.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
constexpr uint8_t PIN_TRIG = 18;
constexpr uint8_t PIN_ECHO = 19; // OBLIGATORIO divisor de voltaje si HC-SR04 ECHO=5V
constexpr uint8_t PIN_POT = 34;
constexpr uint8_t PIN_BTN = 4;
constexpr uint8_t PIN_LED = 23;
constexpr uint8_t PIN_SDA = 21;
constexpr uint8_t PIN_SCL = 22;
constexpr uint8_t OLED_ADDR = 0x3C;
constexpr int W = 128, H_OLED = 64;
Adafruit_SSD1306 oled(W, H_OLED, &Wire, -1);
constexpr uint16_t ALTURA_MIN_CM = 10;
constexpr uint16_t ALTURA_MAX_CM = 250;
constexpr uint8_t UMBRAL_BAJO = 20; // LED alerta al 20% o menos
constexpr uint32_t PERIODO_MEDIDA_MS = 600;
constexpr uint32_t PERIODO_PANTALLA_MS = 150;
constexpr uint32_t DEBOUNCE_MS = 40;
constexpr uint32_t PULSACION_LARGA_MS = 2000;
constexpr uint32_t TIMEOUT_ECHO_US = 25000;
constexpr size_t EEPROM_BYTES = 32;
constexpr uint32_t FIRMA = 0xA64E1201;
struct Config {
uint32_t firma;
uint16_t alturaCm;
uint16_t verificador;
};
bool calibrando = true;
uint16_t alturaCm = 100;
uint16_t alturaGuardada = 0;
bool existeGuardada = false;
float distanciaCm = NAN;
float porcentaje = NAN;
bool lecturaValida = false;
uint32_t tMedida = 0;
uint32_t tPantalla = 0;
bool btnAnterior = HIGH;
bool btnEstable = HIGH;
uint32_t tRebote = 0;
uint32_t tPresionado = 0;
bool largaAtendida = false;
uint16_t comprobacion(uint16_t h) { return (uint16_t)(h ^ 0x5A3C); }
bool cargarAltura(uint16_t &h) {
Config c;
EEPROM.get(0, c);
if (c.firma != FIRMA || c.alturaCm < ALTURA_MIN_CM ||
c.alturaCm > ALTURA_MAX_CM || c.verificador != comprobacion(c.alturaCm)) {
return false;
}
h = c.alturaCm;
return true;
}
bool guardarAltura(uint16_t h) {
Config c = {FIRMA, h, comprobacion(h)};
EEPROM.put(0, c);
return EEPROM.commit();
}
float medirDistanciaCm() {
digitalWrite(PIN_TRIG, LOW);
delayMicroseconds(3);
digitalWrite(PIN_TRIG, HIGH);
delayMicroseconds(10);
digitalWrite(PIN_TRIG, LOW);
unsigned long duracion = pulseIn(PIN_ECHO, HIGH, TIMEOUT_ECHO_US);
if (duracion == 0) return NAN;
float d = duracion * 0.0343f / 2.0f;
if (d < 2.0f || d > 400.0f) return NAN;
return d;
}
void iniciarMedicion() {
if (!guardarAltura(alturaCm)) {
Serial.println("ERROR al guardar EEPROM");
return; // sin guardar NO comienza la medicion
}
alturaGuardada = alturaCm;
existeGuardada = true;
calibrando = false;
lecturaValida = false;
distanciaCm = NAN;
porcentaje = NAN;
tMedida = millis() - PERIODO_MEDIDA_MS;
Serial.printf("Altura guardada: %u cm. Iniciando medicion.\n", alturaCm);
}
void revisarBoton(uint32_t ahora) {
bool bruto = digitalRead(PIN_BTN);
if (bruto != btnAnterior) tRebote = ahora;
if (ahora - tRebote >= DEBOUNCE_MS && bruto != btnEstable) {
btnEstable = bruto;
if (btnEstable == LOW) {
tPresionado = ahora;
largaAtendida = false;
} else {
if (!largaAtendida && calibrando) iniciarMedicion();
}
}
btnAnterior = bruto;
if (btnEstable == LOW && !largaAtendida &&
ahora - tPresionado >= PULSACION_LARGA_MS) {
largaAtendida = true;
if (!calibrando) {
calibrando = true;
lecturaValida = false;
digitalWrite(PIN_LED, LOW);
Serial.println("Regreso al ajuste de altura");
}
}
}
void dibujarOLED() {
oled.clearDisplay();
oled.setTextSize(1);
oled.setTextColor(SSD1306_WHITE);
oled.setCursor(0, 0);
if (calibrando) {
oled.println("CONFIGURAR TANQUE");
oled.drawLine(0, 10, 127, 10, SSD1306_WHITE);
oled.setCursor(0, 16);
oled.print("Altura: "); oled.print(alturaCm); oled.println(" cm");
if (existeGuardada) {
oled.print("Anterior: "); oled.print(alturaGuardada); oled.println(" cm");
} else {
oled.println("Sin altura guardada");
}
oled.println("Pot: ajustar altura");
oled.println("Boton: guardar/iniciar");
oled.println("10 a 250 cm");
} else {
oled.println("MONITOR NIVEL AGUA");
oled.drawLine(0, 10, 127, 10, SSD1306_WHITE);
if (!lecturaValida) {
oled.setCursor(0, 22);
oled.println("ERROR DE LECTURA");
oled.println("Revisar sensor");
} else {
oled.setCursor(0, 15);
oled.print("Nivel: "); oled.print(porcentaje, 1); oled.println(" %");
oled.print("Agua: ");
oled.print(constrain(alturaCm - distanciaCm, 0.0f, (float)alturaCm), 1);
oled.println(" cm");
oled.print("Dist: "); oled.print(distanciaCm, 1); oled.println(" cm");
int ancho = (int)roundf(porcentaje * 1.22f);
oled.drawRect(2, 48, 124, 12, SSD1306_WHITE);
oled.fillRect(3, 49, constrain(ancho, 0, 122), 10, SSD1306_WHITE);
}
// El boton largo permite regresar a configuracion
}
oled.display();
}
void setup() {
Serial.begin(115200);
pinMode(PIN_TRIG, OUTPUT);
pinMode(PIN_ECHO, INPUT);
pinMode(PIN_POT, INPUT);
pinMode(PIN_BTN, INPUT_PULLUP);
pinMode(PIN_LED, OUTPUT);
digitalWrite(PIN_LED, LOW);
digitalWrite(PIN_TRIG, LOW);
analogReadResolution(12);
Wire.begin(PIN_SDA, PIN_SCL);
if (!oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
Serial.println("No se detecto OLED SSD1306");
while (true) delay(1000);
}
if (!EEPROM.begin(EEPROM_BYTES)) {
Serial.println("No se pudo iniciar EEPROM");
while (true) delay(1000);
}
existeGuardada = cargarAltura(alturaGuardada);
if (existeGuardada) Serial.printf("Altura en EEPROM: %u cm\n", alturaGuardada);
// Siempre requiere confirmar con boton ANTES de medir.
calibrando = true;
dibujarOLED();
}
void loop() {
uint32_t ahora = millis();
revisarBoton(ahora);
if (calibrando) {
// Promedio simple de 8 lecturas para estabilizar el control
uint32_t suma = 0;
for (int i = 0; i < 8; ++i) suma += analogRead(PIN_POT);
uint16_t adc = suma / 8;
alturaCm = ALTURA_MIN_CM + (uint32_t)adc *
(ALTURA_MAX_CM - ALTURA_MIN_CM) / 4095UL;
digitalWrite(PIN_LED, LOW);
} else {
if (ahora - tMedida >= PERIODO_MEDIDA_MS) {
tMedida = ahora;
float d = medirDistanciaCm();
lecturaValida = isfinite(d) && d <= alturaCm + 5.0f;
if (lecturaValida) {
distanciaCm = d;
porcentaje = constrain(100.0f * (alturaCm - distanciaCm) /
(float)alturaCm, 0.0f, 100.0f);
Serial.printf("H=%u cm | Dist=%.1f cm | Nivel=%.1f%%\n",
alturaCm, distanciaCm, porcentaje);
} else {
distanciaCm = NAN;
porcentaje = NAN;
Serial.println("ERROR: eco ausente o fuera de rango");
}
}
// LED parpadeante: bajo nivel (500 ms), error (150 ms)
if (!lecturaValida) {
digitalWrite(PIN_LED, (ahora / 150) % 2);
} else if (porcentaje <= UMBRAL_BAJO) {
digitalWrite(PIN_LED, (ahora / 500) % 2);
} else {
digitalWrite(PIN_LED, LOW);
}
}
if (ahora - tPantalla >= PERIODO_PANTALLA_MS) {
tPantalla = ahora;
dibujarOLED();
}
}
También puedes adjuntar el archivo Monitor_Nivel_Agua_ESP32.ino como descarga en tu biblioteca de medios y enlazarlo aquí: Descargar código ESP32.
Calibración y pruebas
- Primero prueba el sensor y la OLED sobre una mesa, con el divisor de tensión conectado correctamente.
- Mide con una regla la distancia entre la cara del sensor y el fondo del tanque (H).
- Gira el potenciómetro hasta esa altura; pulsa brevemente para guardar y empezar la medición.
- Prueba a diferentes distancias con una superficie plana antes de instalarlo sobre agua.
- Verifica que el LED parpadea cuando el nivel es bajo y ante fallos de lectura.
- Apaga y enciende el ESP32: la altura anterior aparecerá como referencia guardada. Confirma de nuevo con el botón para medir.
Preguntas frecuentes
¿Se guarda la altura cuando desconecto la energía?
Sí. Se conserva en la flash mediante EEPROM emulada. Evita guardar repetidamente en cada ciclo para no provocar desgaste innecesario. En este programa solo se guarda cuando confirmas con el botón.
¿Sirve para cualquier tanque?
Solo cuando hay trayectoria ultrasónica despejada y la distancia está dentro del rango práctico del sensor. Espuma, condensación, paredes angostas y vapores pueden alterar las lecturas. Para exterior o lugares muy húmedos conviene un transductor impermeable especificado para esa aplicación.
¿Por qué no llega al 100 % cuando está lleno?
El sensor tiene una zona cercana en la que no puede medir confiablemente. Si el nivel máximo queda muy próximo al transductor, será necesario elevar su posición o definir un margen de llenado seguro. Además, H debe medirse desde la cara del sensor hasta el fondo.
¿Puede activar automáticamente una bomba?
Esta versión solo monitorea y advierte con LED: no controla bombas ni válvulas. Añadir potencia requiere un diseño eléctrico y controles de seguridad adicionales.
Conclusión
Con pocos componentes puedes construir un monitor de agua autónomo con ESP32, calibración sencilla y configuración persistente. Es un excelente proyecto educativo para aprender ultrasonido, lectura analógica, memorias no volátiles, pantallas OLED y lógica de estados.
¿Te interesa otro tutorial? Comparte el proyecto y comenta qué mejora te gustaría: alerta sonora, porcentaje de volumen o sensor impermeable.
