SENSOR DE NIVEL DE AGUA CON ARDUINO

https://programarfacil.com/blog/arduino-blog/sensor-de-nivel-de-agua-con-arduino/

Cuando trabajo con Arduino, una de las cosas que más me gusta es poder crear
dispositivos o aplicaciones como si estuviera jugando con un LEGO o Tente. Es increíble las
posibilidades que nos brinda el Open Hardware. En este artículo vamos a ver un ejemplo
de cómo podemos crear un sensor de nivel de agua con Arduino. Cuando hablo de agua
puede ser cualquier líquido e incluso sustancias sólidas. Lo único que debemos de tener
en cuenta es la capacidad del recipiente.

Una de las formas más sencillas es utilizar el sensor de ultrasonidos. Ya he hablado

en algún otro artículo de este sensor. Veremos las características principales para
utilizarlo con Arduino. El otro componente será una pantalla LCD. Aquí es donde
visualizaremos en todo momento la cantidad de agua o líquido que queda en el recipiente.

La aplicación es sencilla, con el sensor de ultrasonidos mediremos cuanta distancia hay

hasta el líquido. Debemos conocer el recipiente para saber cuánta cantidad cabe y que
medida se obtiene cuando está lleno. Lo mismo haremos cuando el recipiente esté vacío.
Esto se llama calibración.

La pantalla LCD nos mostrará el porcentaje de líquido que nos queda en el recipiente y su

equivalente en litros.

En este proyecto haremos uso de las matemáticas a nivel básico y de la programación a un

nivel medio. Te lo iré explicando todo paso a paso para que quede todo bien claro.

El sensor de nivel de agua con Arduino nos permite medir cualquier líquido gracias al
sensor de ultrasonidos.
La pieza más importante en este proyecto será el Arduino. En este caso podemos utilizar
cualquier modelo que tenga como mínimo 8 entradas digitales. En este tutorial trabajaré
con la placa más famosa de Arduino, la UNO.

El proyecto va a constar de diferentes fases donde iremos avanzando para conseguir

nuestro objetivo.

 Circuito eléctrico, conectando los componentes

 Probar todos los componentes y conexiones
 Montando el sensor en la cubeta
 Calibrando el sensor de nivel de agua con Arduino
 Mostrando los datos en el LCD
Componentes necesarios para el sensor de nivel de agua con Arduino
Lo primero que debemos hacer si queremos crear un sensor de nivel de agua con Arduino,
es conocer los componentes que vamos a utilizar. Por supuesto que esto es solo una idea,
de todos los componentes que voy a detallar a continuación, alguno es prescindible.

ARDUINO UNO

Será el cerebro de la aplicación y el encargado de gestionar todos los sensores a través de

las entradas y salidas digitales. En la programación reside su potencia. Veremos que
código debemos implementar para poder medir el nivel en un recipiente.

Precio: 23,33€

SENSOR ULTRASONIDOS HC-SR04

Ya hemos visto en diferentes artículos e incluso un capítulo del podcast cómo funciona

este sensor. No voy a entrar en detalle en su funcionamiento solo comentar que este tipo
de sensores se basan en medir cuanto tiempo tarda en viajar una onda ultrasónica desde
que sale del sensor hasta que regresa.
Gracias a este tiempo y sabiendo la velocidad del sonido, es fácil calcular la distancia
aplicando la famosa fórmula.

Precio: 1,49€

PANTALLA LCD 16×2

Este componente también lo hemos visto en varios artículos. Mostrando texto en

movimiento y mostrando la temperatura de un sensor. Consiste en una pantalla de cristal
líquido de 16 columnas y 2 filas. En ella iremos escribiendo los resultados obtenidos de las
mediciones, así como alguna otra información útil en este proyecto.

Precio: 2,84€

DEMÁS COMPONENTES ELECTRÓNICOS

Además de los componentes esenciales para el sensor de nivel de agua con Arduino,
vamos a necesitar los típicos componentes que se suelen utilizar en muchos circuitos. Te
los detallo a continuación.

 Protoboard (1,92€)
 Potenciómetro 10kΩ (1,60€)
 Resistencia 220Ω (3,49€)
 Cables (8,99€)

CIRCUITO ELÉCTRICO
Con todos los componentes en nuestro poder, ya podemos empezar a montar el circuito.
Como ya he comentado al principio del artículo, vamos a necesitar 8 entradas y salidas
digitales. Además utilizaremos el pin de 5V y el GND (toma de tierra). El circuito sería el
siguiente.
PROBAR TODOS LOS COMPONENTES Y CONEXIONES
Antes de meternos en faena y empezar a programar el sensor de nivel de agua con
Arduino, vamos a probar los diferentes componentes del circuito eléctrico. Es importante
asegurarnos de que todo está bien conectado. Lo más sencillo es probar cada componente
por separado y así es como lo haremos.

SENSOR DE ULTRASONIDOS HC-SR04

Para probar este sensor vamos a cargar un sketch que no servirá más adelante a la hora
de medir el nivel. Las conexiones Echo y Trigger van a los pines 6 y 7 respectivamente.
Carga el siguiente sketch en tu placa de Arduino y comprueba el monitor serie.

// Configuramos los pines del sensor Trigger y Echo

const int PinTrig = 7;
const int PinEcho = 6;

// Constante velocidad sonido en cm/s

const float VelSon = 34000.0;
float distancia;

void setup()
{
  // Iniciamos el monitor serie para mostrar el resultado
  Serial.begin(9600);
  // Ponemos el pin Trig en modo salida
  pinMode(PinTrig, OUTPUT);
  // Ponemos el pin Echo en modo entrada
  pinMode(PinEcho, INPUT);
}
void loop()
{
  iniciarTrigger();
  
  // La función pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este caso a HIGH
  unsigned long tiempo = pulseIn(PinEcho, HIGH);
  
  // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que está en microsegundos
  // por eso se multiplica por 0.000001
  distancia = tiempo * 0.000001 * VelSon / 2.0;
  Serial.print(distancia);
  Serial.print("cm");
  Serial.println();
  delay(500);
}

// Método que inicia la secuencia del Trigger para comenzar a medir

void iniciarTrigger()
{
  // Ponemos el Triiger en estado bajo y esperamos 2 ms
  digitalWrite(PinTrig, LOW);
  delayMicroseconds(2);
  
  // Ponemos el pin Trigger a estado alto y esperamos 10 ms
  digitalWrite(PinTrig, HIGH);
  delayMicroseconds(10);

// Comenzamos poniendo el pin Trigger en estado bajo

  digitalWrite(PinTrig, LOW);
}

En el monitor serie debe aparecer algo parecido a lo siguiente

Si el resultado es siempre 0 cm, debes comprobar las conexiones que estén todas
correctas según el esquema que hemos visto antes.

Pantalla LCD 16X2

Como su nombre indica, se trata de una pantalla de 16 columnas y 2 filas. Esto nos va a
permitir escribir un total de 32 caracteres a la vez. Ahora lo que haremos es escribir un
simple texto para comprobar que todo está bien conectado. Carga el siguiente sketch en
tu placa.

// Incluímos la libreria externa para poder utilizarla

#include <LiquidCrystal.h> // Entre los símbolos <> buscará en la carpeta de librerías configurada

// Lo primero is inicializar la librería indicando los pins de la interfaz

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Definimos las constantes

#define COLS 16 // Columnas del LCD
#define ROWS 2 // Filas del LCD

void setup() {
  // Configuramos las filas y las columnas del LCD en este caso 16 columnas y 2 filas
  lcd.begin(COLS, ROWS);
}

void loop() {
 
  lcd.setCursor(0,0);
  lcd.print("Hola Mundo!!!!!!");
  lcd.setCursor(0,1);
  lcd.print("Probando el LCD.");
}

Por lo tanto, el resultado que debemos obtener es el texto «Hola Mundo!!!!!!» en la

primera fila y en la segunda fila «Probando el LCD.». Debes obtener algo parecido a esto.

Montando el sensor en la cubeta

Ya hemos montado todo el circuito, hemos comprobado que todo funciona
correctamente y ahora vamos a montar el sensor encima del recipiente o cubeta donde
vamos a tener el líquido. Lo podemos hacer de muchas formas, yo te voy a mostrar una
muy sencilla utilizando dos palos de madera que se utilizan para cocinar. Son los típicos
para saber si el bizcocho está hecho o para hacer brochetas.

Además, he utilizado dos alambres de los típicos que vienen en cualquier embalaje para
sujetar cables. Suelo recolectar este tipo de agarres ya que son muy útiles en muchas
ocasiones. El resultado lo puedes ver en las siguientes imagenes .
Gracias a estos dos palos podemos situar el ultrasonidos baca abajo encima de cualquier
recipiente o cubeta. En la siguiente imagen te muestro un ejemplo de cómo quedaría.

Esto también nos puede servir de sujeción con alguna goma elástica u otro
método para que no se mueva.

Calibrando el sensor de nivel de agua con Arduino

Ha llegado la hora de empezar a programar. Lo primero que debemos hacer es calibrar el
sensor de nivel de agua con Arduino. Para ello voy a utilizar un vaso medidor es decir, un
vaso que tiene marcadas las medidas. Así podremos asignar una medida del sensor de
ultrasonidos a una cantidad de líquido. Esto nos permitirá saber que cantidad de líquido
tenemos en el recipiente.

Algo que tienes que tener en cuenta es que el sensor de ultrasonidos mide la cantidad de
espacio vacío en el recipiente. Por lo tanto, si conocemos la capacidad total del recipiente,
al restar la cantidad de espacio vacío sabremos cuánto líquido hay. Mira el esquema
general.
Entonces, según este esquema general debemos conocer que valor obtenemos con el
sensor de ultrasonidos cuando está vacío, cuando está lleno y una medida conocida. Esta
última medida la haremos con vaso medidor calculando el valor para 100 ml.

Antes de comenzar con las medidas, debemos de tener en cuenta que el vaso debe ser
cilíndrico es decir, la base debe ser del mismo diámetro que la parte de arriba. Si
intentamos medir en un recipiente que no es cilíndrico, en forma de cono, las medidas no
serán proporcionales.

Calcular la media para eliminar el ruido

En todos los sistemas electrónicos se genera un ruido debido al movimiento de los
electrones, al propio sensor, la placa de Arduino, etc… Esto se traduce en una variación o
fluctuación en las medidas que vamos obteniendo a través del sensor. Para eliminar este
tipo de ruido se suele aplicar un filtro paso bajo que elimina las frecuencias bajas, justo
donde se encuentra el ruido. La forma más sencilla de aplicarlo a través de la
programación es hacer una media de los valores que se van obteniendo.

Pero no solo para eliminar el ruido, calculando la media podemos eliminar las
fluctuaciones debidas al movimiento del recipiente. Imagínate un depósito de gasolina de
un coche. Cuando va en marcha el combustible no está quieto, se va moviendo. Si se
quiere medir con un sensor de ultrasonidos sería complicado si no se utiliza alguna técnica
como esta.

Dependiendo del número de muestras que utilicemos para obtener la media, podremos
tener un valor más preciso o menos preciso. Pero esto también influye en cuánto tarda en
estabilizarse la medida cuando se produce un cambio. Por lo tanto, si cogemos un número
alto de muestras, la media será más precisa pero tardará más tiempo en reflejar los
cambios. Por el contrario, si cogemos un número bajo de muestras, la media será menos
precisa pero veremos reflejados más rápidos los cambios. Elegir uno u otro dependerá de
lo que queramos conseguir, rapidez o precisión.

Otro factor a tener en cuenta es el tamaño del tipo de dato que vamos a
almacenar. Debemos de tener mucho ojo ya que podemos provocar un desbordamiento.
Todas las muestras se irán almacenando en una variable para luego calcular la media, por
lo tanto si elegimos un número alto de muestras debemos asegurarnos que no nos
saldremos de rango.

En este caso yo voy a elegir precisión, voy a coger un rango de muestras de 100. El código
es muy parecido al que hemos utilizado para probar el sensor de ultrasonidos al que he
añadido el cálculo de la media cada 100 valores. No voy a profundizar más en esta técnica,
si quieres aprender todo lo que hay detrás te aconsejo que veas la lección donde muestro
como estabilizar el sensor de temperatura LM35.

El código que debes cargar en tu placa es el siguiente

// Configuramos los pines del sensor Trigger y Echo
const int PinTrig = 7;
const int PinEcho = 6;
 
// Constante velocidad sonido en cm/s
const float VelSon = 34000.0;
 
// Número de muestras
const int numLecturas = 100;
 
float lecturas[numLecturas]; // Array para almacenar lecturas
int lecturaActual = 0; // Lectura por la que vamos
float total = 0; // Total de las que llevamos
float media = 0; // Media de las medidas
bool primeraMedia = false; // Para saber que ya hemos calculado por lo menos una
 
void setup()
{
  // Iniciamos el monitor serie para mostrar el resultado
  Serial.begin(9600);
  // Ponemos el pin Trig en modo salida
  pinMode(PinTrig, OUTPUT);
  // Ponemos el pin Echo en modo entrada
  pinMode(PinEcho, INPUT);
 
  // Inicializamos el array
  for (int i = 0; i < numLecturas; i++)
  {
    lecturas[i] = 0;
  }
}
void loop()
{
  // Eliminamos la última medida
  total = total - lecturas[lecturaActual];
 
  iniciarTrigger();
 
  // La función pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este caso a HIGH
  unsigned long tiempo = pulseIn(PinEcho, HIGH);
 
  // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que está en microsegundos
  // por eso se multiplica por 0.000001
  float distancia = tiempo * 0.000001 * VelSon / 2.0;
 
  // Almacenamos la distancia en el array
  lecturas[lecturaActual] = distancia;
 
  // Añadimos la lectura al total
  total = total + lecturas[lecturaActual];
 
  // Avanzamos a la siguiente posición del array
  lecturaActual = lecturaActual + 1;
 
  // Comprobamos si hemos llegado al final del array
  if (lecturaActual >= numLecturas)
  {
    primeraMedia = true;
    lecturaActual = 0;
  }
 
  // Calculamos la media
  media = total / numLecturas;
 
  // Solo mostramos si hemso calculado por lo menos una media
  if (primeraMedia)
  {
    Serial.print(media);
    Serial.println("cm");
  }
 
  delay(500);
}
 
// Método que inicia la secuencia del Trigger para comenzar a medir
void iniciarTrigger()
{
  // Ponemos el Triiger en estado bajo y esperamos 2 ms
  digitalWrite(PinTrig, LOW);
  delayMicroseconds(2);
 
  // Ponemos el pin Trigger a estado alto y esperamos 10 ms
  digitalWrite(PinTrig, HIGH);
  delayMicroseconds(10);
 
  // Comenzamos poniendo el pin Trigger en estado bajo
  digitalWrite(PinTrig, LOW);
}

Estos son los datos que yo he obtenido, seguramente tu hayas obtenido otros valores,
dependerá del recipiente y de la cantidad de líquido que entre en dicho recipiente.
 CALCULANDO EL NIVEL DE LÍQUIDO
Con los datos obtenidos en la fase anterior, con el recipiente en vacío, lleno y con 100 ml,
ya podemos obtener una fórmula para el sensor de nivel de agua con Arduino. Las
medidas obtenidas nos indican la cantidad de espacio vacío que hay en el recipiente.
Vamos a comenzar cambiando el rango para llevarlo a 0 eliminando el offset de 2,20 cm.
Es como si el líquido estuviera a 0 cm cuando el recipiente está cero.

El siguiente paso es calcular cuánto ocupa 100 ml de líquido en nuestro recipiente. Esto se
hace restando la distancia cuando está vacío menos la distancia cuando tiene 100 ml.

Esta medida nos dice que cada 2,15 cm hay 100 ml de líquido. Con esto ya es sencillo
calcular cuánto líquido hay dentro del recipiente. Vamos a hacerlo con un ejemplo.
Supongamos que el sensor de ultrasonidos nos da una distancia de 7,11 cm. Ese sería el
espacio vacío pero nosotros queremos saber cuánto espacio queda lleno. Lo calculamos
restando la distancia en vacío menos la distancia obtenida.

Como sabemos que cada 2,15 cm hay 100 ml, aplicando una simple regla de 3 sabremos la
cantidad de líquido que tenemos.
 

Pues ya tenemos la base matemática para calcular el nivel de líquido en nuestro

recipiente, ahora solo nos queda aplicar dichos cálculos en nuestro sketch.

PROGRAMANDO EL SKETCH PARA CALCULAR EL NIVEL

Todo esto tenemos que plasmarlo en un sketch para subirlo a nuestro Arduino. A
continuación, te dejo el código para que veas como lo he hecho. Fíjate en los comentarios.

// Configuramos los pines del sensor Trigger y Echo

const int PinTrig = 7;
const int PinEcho = 6;
 
// Constante velocidad sonido en cm/s
const float VelSon = 34000.0;
 
// Número de muestras
const int numLecturas = 100;
 
// Distancia a los 100 ml y vacío
const float distancia100 = 2.15;
const float distanciaVacio = 11.41;
 
float lecturas[numLecturas]; // Array para almacenar lecturas
int lecturaActual = 0; // Lectura por la que vamos
float total = 0; // Total de las que llevamos
float media = 0; // Media de las medidas
bool primeraMedia = false; // Para saber que ya hemos calculado por lo menos una
 
void setup()
{
  // Iniciamos el monitor serie para mostrar el resultado
  Serial.begin(9600);
  // Ponemos el pin Trig en modo salida
  pinMode(PinTrig, OUTPUT);
  // Ponemos el pin Echo en modo entrada
  pinMode(PinEcho, INPUT);
 
  // Inicializamos el array
  for (int i = 0; i < numLecturas; i++)
  {
    lecturas[i] = 0;
  }
}
void loop()
{
  // Eliminamos la última medida
  total = total - lecturas[lecturaActual];
 
  iniciarTrigger();
 
  // La función pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este caso a HIGH
  unsigned long tiempo = pulseIn(PinEcho, HIGH);
 
  // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que está en microsegundos
  // por eso se multiplica por 0.000001
  float distancia = tiempo * 0.000001 * VelSon / 2.0;
 
  // Almacenamos la distancia en el array
  lecturas[lecturaActual] = distancia;
 
  // Añadimos la lectura al total
  total = total + lecturas[lecturaActual];
 
  // Avanzamos a la siguiente posición del array
  lecturaActual = lecturaActual + 1;
 
  // Comprobamos si hemos llegado al final del array
  if (lecturaActual >= numLecturas)
  {
    primeraMedia = true;
    lecturaActual = 0;
  }
 
  // Calculamos la media
  media = total / numLecturas;
 
  // Solo mostramos si hemos calculado por lo menos una media
  if (primeraMedia)
  {
    float distanciaLleno = distanciaVacio - media;
    float cantidadLiquido = distanciaLleno * 100 / distancia100;
 
    Serial.print(media);
    Serial.println(" cm");
    
    Serial.print(cantidadLiquido);
    Serial.println(" ml");
  }
 
  delay(500);
}
 
// Método que inicia la secuencia del Trigger para comenzar a medir
void iniciarTrigger()
{
  // Ponemos el Triiger en estado bajo y esperamos 2 ms
  digitalWrite(PinTrig, LOW);
  delayMicroseconds(2);
 
  // Ponemos el pin Trigger a estado alto y esperamos 10 ms
  digitalWrite(PinTrig, HIGH);
  delayMicroseconds(10);
 
  // Comenzamos poniendo el pin Trigger en estado bajo
  digitalWrite(PinTrig, LOW);
}

MOSTRANDO LOS DATOS EN EL LCD

Por último y, aunque no es necesario, vamos a mostrar la información en una pantalla LCD
de 16×2. La información que vamos a mostrar es la cantidad de líquido en ml y el
porcentaje de llenado. Estos datos son fundamentales en el sensor de nivel de agua con
Arduino.

El siguiente código lo único que hago es mezclar el código anterior donde obtenemos la
cantidad de líquido y el código con el que hemos probado el LCD.

// Incluímos la libreria externa para poder utilizarla

#include <LiquidCrystal.h> // Entre los símbolos <> buscará en la carpeta de librerías configurada
 
// Lo primero is inicializar la librería indicando los pins de la interfaz
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
 
// Definimos las constantes
#define COLS 16 // Columnas del LCD
#define ROWS 2 // Filas del LCD
 
// Configuramos los pines del sensor Trigger y Echo
const int PinTrig = 7;
const int PinEcho = 6;
 
// Constante velocidad sonido en cm/s
const float VelSon = 34000.0;
 
// Número de muestras
const int numLecturas = 100;
 
// Distancia a los 100 ml y vacío
const float distancia100 = 2.15;
const float distanciaVacio = 11.41;
 
float lecturas[numLecturas]; // Array para almacenar lecturas
int lecturaActual = 0; // Lectura por la que vamos
float total = 0; // Total de las que llevamos
float media = 0; // Media de las medidas
bool primeraMedia = false; // Para saber que ya hemos calculado por lo menos una
 
void setup()
{
  // Iniciamos el monitor serie para mostrar el resultado
  Serial.begin(9600);
  // Ponemos el pin Trig en modo salida
  pinMode(PinTrig, OUTPUT);
  // Ponemos el pin Echo en modo entrada
  pinMode(PinEcho, INPUT);
 
  // Inicializamos el array
  for (int i = 0; i < numLecturas; i++)
  {
    lecturas[i] = 0;
  }
 
  // Configuramos las filas y las columnas del LCD en este caso 16 columnas y 2 filas
  lcd.begin(COLS, ROWS);
}
void loop()
{
  // Eliminamos la última medida
  total = total - lecturas[lecturaActual];
 
  iniciarTrigger();
 
  // La función pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este caso a HIGH
  unsigned long tiempo = pulseIn(PinEcho, HIGH);
 
  // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que está en microsegundos
  // por eso se multiplica por 0.000001
  float distancia = tiempo * 0.000001 * VelSon / 2.0;
 
  // Almacenamos la distancia en el array
  lecturas[lecturaActual] = distancia;
 
  // Añadimos la lectura al total
  total = total + lecturas[lecturaActual];
 
  // Avanzamos a la siguiente posición del array
  lecturaActual = lecturaActual + 1;
 
  // Comprobamos si hemos llegado al final del array
  if (lecturaActual >= numLecturas)
  {
    primeraMedia = true;
    lecturaActual = 0;
  }
 
  // Calculamos la media
  media = total / numLecturas;
 
  // Solo mostramos si hemos calculado por lo menos una media
  if (primeraMedia)
  {
    float distanciaLleno = distanciaVacio - media;
    float cantidadLiquido = distanciaLleno * 100 / distancia100;
    int porcentaje = (int) (distanciaLleno * 100 / distanciaVacio);
 
    // Mostramos en la pantalla LCD
    lcd.clear();
    // Cantidada de líquido
    lcd.setCursor(0, 0);
    lcd.print(String(cantidadLiquido) + " ml");
 
    // Porcentaje
    lcd.setCursor(0, 1);
    lcd.print(String(porcentaje) + " %");
 
    Serial.print(media);
    Serial.println(" cm");
 
    Serial.print(cantidadLiquido);
    Serial.println(" ml");
  }
  else
  {
    lcd.setCursor(0, 0);
    lcd.print("Calculando: " + String(lecturaActual));
  }
 
  delay(500);
}
 
// Método que inicia la secuencia del Trigger para comenzar a medir
void iniciarTrigger()
{
  // Ponemos el Triiger en estado bajo y esperamos 2 ms
  digitalWrite(PinTrig, LOW);
  delayMicroseconds(2);
 
  // Ponemos el pin Trigger a estado alto y esperamos 10 ms
  digitalWrite(PinTrig, HIGH);
  delayMicroseconds(10);
 
  // Comenzamos poniendo el pin Trigger en estado bajo
  digitalWrite(PinTrig, LOW);
}

CONCLUSIONES
En este tutorial hemos visto como crear un sensor de nivel de agua con Arduino. Con un
presupuesto inicial de unos 44 € hemos podido realizar un proyecto de principio a fin. En
este presupuesto no entran las horas de programación ni de imaginación, eso muchas
veces no es cuantificable. Sin duda alguna este proyecto se puede mejorar y te animo a
que lo hagas. Te voy a dar unas pautas donde podrías aplicar mejoras para que puedas
utilizarlo en ambientes donde se exija mayor precisión y estabilidad.

 Utilizar un sensor de ultrasonidos más preciso y potente

 Soporte para el sensor con anclajes que no permita que se mueva
 Crear una PCB con todos los componentes
CON ARDUINO NANO
http://arduinoencasa.com/2-formas-de-controlar-el-nivel-de-agua-con-arduino-casero-
utrasonidos-y-sensor/