Sei sulla pagina 1di 27

Sensor de nivel de agua con Arduino 

Comentarios(62) 
Luis del Valle Hernández 

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 solidas. 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 cuanta 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. 

Indice de contenidos 

1 El sensor de nivel de agua con Arduino nos permite medir cualquier líquido gracias al sensor de 
ultrasonidos. 

2 Componentes necesarios para el sensor de nivel de agua con Arduino 

3 Circuito elétrico 

4 Montando el sensor en la cubeta 

5 Calibrando el sensor de nivel de agua con Arduino 

6 Mostrando los datos en el LCD 

7 Conclusiones 

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. 

 
¿Quieres montar tu primer proyecto con Arduino? 

Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso a paso y en 
sólo una semana. 

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étrico 

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. 

C++ 
1  // Configuramos los pines del sensor Trigger y Echo 

2  const int PinTrig = 7; 

3  const int PinEcho = 6; 

4  // Constante velocidad sonido en cm/s 

5  const float VelSon = 34000.0; 

6  float distancia; 

7  void setup() 

8  { 

9    // Iniciamos el monitor serie para mostrar el resultado 

10    Serial.begin(9600); 

11    // Ponemos el pin Trig en modo salida 

12    pinMode(PinTrig, OUTPUT); 

13    // Ponemos el pin Echo en modo entrada 

14    pinMode(PinEcho, INPUT); 

15  } 

16  void loop() 

17  { 

18    iniciarTrigger(); 

19     

20    // La función pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este caso 
a HIGH 
21 
  unsigned long tiempo = pulseIn(PinEcho, HIGH); 
22 
   
23 
  // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que está en 
24 
microsegundos 
25 
  // por eso se multiplica por 0.000001 
26 
  distancia = tiempo * 0.000001 * VelSon / 2.0; 
27 
  Serial.print(distancia); 
28 
  Serial.print("cm"); 
29    Serial.println(); 

30    delay(500); 

31  } 

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

33  void iniciarTrigger() 

34  { 

35    // Ponemos el Triiger en estado bajo y esperamos 2 ms 

36    digitalWrite(PinTrig, LOW); 

37    delayMicroseconds(2); 

38     

39    // Ponemos el pin Trigger a estado alto y esperamos 10 ms 

40    digitalWrite(PinTrig, HIGH); 

41    delayMicroseconds(10); 

42     

43    // Comenzamos poniendo el pin Trigger en estado bajo 

44    digitalWrite(PinTrig, LOW); 

45  } 

46 

47 

48 

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. 

C++ 

 
1  // Incluímos la libreria externa para poder utilizarla 

2  #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 
10 
  lcd.begin(COLS, ROWS); 
11 

12 
void loop() { 
13 
  
14 
  lcd.setCursor(0,0); 
15 
  lcd.print("Hola Mundo!!!!!!"); 
16 
  lcd.setCursor(0,1); 
17 
  lcd.print("Probando el LCD."); 
18 

19 

20 

21 

22 

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 deposito 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 

C++ 

// Configuramos los pines del se


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

1  // Configuramos los pines del sensor Trigger y Echo 

2  const int PinTrig = 7; 

3  const int PinEcho = 6; 

4    

5  // Constante velocidad sonido en cm/s 

6  const float VelSon = 34000.0; 

7    

8  // Número de muestras 

9  const int numLecturas = 100; 

10    

11  float lecturas[numLecturas]; // Array para almacenar lecturas 

12  int lecturaActual = 0; // Lectura por la que vamos 

13  float total = 0; // Total de las que llevamos 

14  float media = 0; // Media de las medidas 

15  bool primeraMedia = false; // Para saber que ya hemos calculado por lo menos una 

16    

17  void setup() 

18  { 

19    // Iniciamos el monitor serie para mostrar el resultado 

20    Serial.begin(9600); 

21    // Ponemos el pin Trig en modo salida 
22    pinMode(PinTrig, OUTPUT); 

23    // Ponemos el pin Echo en modo entrada 

24    pinMode(PinEcho, INPUT); 

25    

26    // Inicializamos el array 

27    for (int i = 0; i < numLecturas; i++) 

28    { 

29      lecturas[i] = 0; 

30    } 

31  } 

32  void loop() 

33  { 

34    // Eliminamos la última medida 

35    total = total ‐ lecturas[lecturaActual]; 

36    

37    iniciarTrigger(); 

38    

39    // La función pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este caso 
a HIGH 
40 
  unsigned long tiempo = pulseIn(PinEcho, HIGH); 
41 
  
42 
  // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que está en 
43 
microsegundos 
44 
  // por eso se multiplica por 0.000001 
45 
  float distancia = tiempo * 0.000001 * VelSon / 2.0; 
46 
  
47 
  // Almacenamos la distancia en el array 
48 
  lecturas[lecturaActual] = distancia; 
49 
  
50    // Añadimos la lectura al total 

51    total = total + lecturas[lecturaActual]; 

52    

53    // Avanzamos a la siguiente posición del array 

54    lecturaActual = lecturaActual + 1; 

55    

56    // Comprobamos si hemos llegado al final del array 

57    if (lecturaActual >= numLecturas) 

58    { 

59      primeraMedia = true; 

60      lecturaActual = 0; 

61    } 

62    

63    // Calculamos la media 

64    media = total / numLecturas; 

65    

66    // Solo mostramos si hemso calculado por lo menos una media 

67    if (primeraMedia) 

68    { 

69      Serial.print(media); 

70      Serial.println("cm"); 

71    } 

72    

73    delay(500); 

74  } 

75    

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

77  void iniciarTrigger() 
78  { 

79    // Ponemos el Triiger en estado bajo y esperamos 2 ms 

80    digitalWrite(PinTrig, LOW); 

81    delayMicroseconds(2); 

82    

83    // Ponemos el pin Trigger a estado alto y esperamos 10 ms 

84    digitalWrite(PinTrig, HIGH); 

85    delayMicroseconds(10); 

86    

87    // Comenzamos poniendo el pin Trigger en estado bajo 

88    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. 

Vacío  Lleno  100 ml 

11,41 cm  2,20 cm  9,26 cm 

 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. 

  

Vacío  Lleno  100 ml 

11,41 cm  2,20 cm  9,26 cm 

9,21 cm  0 cm  7,06 cm 

El siguiente paso es calcular cuanto 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 
cuanto líquido hay dentro del recipiente. Vamos a hacerlo con un ejemplo. Supongamos que el 
sensor de ultrasonidos nos da un distancia de 7,11 cm. Ese sería el espacio vacío pero 
nosotros queremos saber cuanto 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. 

C++ 

// Configuramos los pines del se


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

1  // Configuramos los pines del sensor Trigger y Echo 

2  const int PinTrig = 7; 

3  const int PinEcho = 6; 

4    

5  // Constante velocidad sonido en cm/s 

6  const float VelSon = 34000.0; 

7    

8  // Número de muestras 

9  const int numLecturas = 100; 

10    
11  // Distancia a los 100 ml y vacío 

12  const float distancia100 = 2.15; 

13  const float distanciaVacio = 11.41; 

14    

15  float lecturas[numLecturas]; // Array para almacenar lecturas 

16  int lecturaActual = 0; // Lectura por la que vamos 

17  float total = 0; // Total de las que llevamos 

18  float media = 0; // Media de las medidas 

19  bool primeraMedia = false; // Para saber que ya hemos calculado por lo menos una 

20    

21  void setup() 

22  { 

23    // Iniciamos el monitor serie para mostrar el resultado 

24    Serial.begin(9600); 

25    // Ponemos el pin Trig en modo salida 

26    pinMode(PinTrig, OUTPUT); 

27    // Ponemos el pin Echo en modo entrada 

28    pinMode(PinEcho, INPUT); 

29    

30    // Inicializamos el array 

31    for (int i = 0; i < numLecturas; i++) 

32    { 

33      lecturas[i] = 0; 

34    } 

35  } 

36  void loop() 

37  { 

38    // Eliminamos la última medida 
39    total = total ‐ lecturas[lecturaActual]; 

40    

41    iniciarTrigger(); 

42    

43    // La función pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este caso 
a HIGH 
44 
  unsigned long tiempo = pulseIn(PinEcho, HIGH); 
45 
  
46 
  // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que está en 
47 
microsegundos 
48 
  // por eso se multiplica por 0.000001 
49 
  float distancia = tiempo * 0.000001 * VelSon / 2.0; 
50 
  
51 
  // Almacenamos la distancia en el array 
52 
  lecturas[lecturaActual] = distancia; 
53 
  
54 
  // Añadimos la lectura al total 
55 
  total = total + lecturas[lecturaActual]; 
56 
  
57 
  // Avanzamos a la siguiente posición del array 
58 
  lecturaActual = lecturaActual + 1; 
59 
  
60 
  // Comprobamos si hemos llegado al final del array 
61 
  if (lecturaActual >= numLecturas) 
62 
  { 
63 
    primeraMedia = true; 
64 
    lecturaActual = 0; 
65 
  } 
66 
  
67    // Calculamos la media 

68    media = total / numLecturas; 

69    

70    // Solo mostramos si hemos calculado por lo menos una media 

71    if (primeraMedia) 

72    { 

73      float distanciaLleno = distanciaVacio ‐ media; 

74      float cantidadLiquido = distanciaLleno * 100 / distancia100; 

75    

76      Serial.print(media); 

77      Serial.println(" cm"); 

78       

79      Serial.print(cantidadLiquido); 

80      Serial.println(" ml"); 

81    } 

82    

83    delay(500); 

84  } 

85    

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

87  void iniciarTrigger() 

88  { 

89    // Ponemos el Triiger en estado bajo y esperamos 2 ms 

90    digitalWrite(PinTrig, LOW); 

91    delayMicroseconds(2); 

92    

93    // Ponemos el pin Trigger a estado alto y esperamos 10 ms 

94    digitalWrite(PinTrig, HIGH); 
95    delayMicroseconds(10); 

96    

97    // Comenzamos poniendo el pin Trigger en estado bajo 

98    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. 

C++ 

// Incluímos la libreria externa pa


#include <LiquidCrystal.h> // Ent

// Lo primero is inicializar la libre

1  // Incluímos la libreria externa para poder utilizarla 

2  #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 
10 
  
11 
// Configuramos los pines del sensor Trigger y Echo 
12 
const int PinTrig = 7; 
13 
const int PinEcho = 6; 
14 
15    

16  // Constante velocidad sonido en cm/s 

17  const float VelSon = 34000.0; 

18    

19  // Número de muestras 

20  const int numLecturas = 100; 

21    

22  // Distancia a los 100 ml y vacío 

23  const float distancia100 = 2.15; 

24  const float distanciaVacio = 11.41; 

25    

26  float lecturas[numLecturas]; // Array para almacenar lecturas 

27  int lecturaActual = 0; // Lectura por la que vamos 

28  float total = 0; // Total de las que llevamos 

29  float media = 0; // Media de las medidas 

30  bool primeraMedia = false; // Para saber que ya hemos calculado por lo menos una 

31    

32  void setup() 

33  { 

34    // Iniciamos el monitor serie para mostrar el resultado 

35    Serial.begin(9600); 

36    // Ponemos el pin Trig en modo salida 

37    pinMode(PinTrig, OUTPUT); 

38    // Ponemos el pin Echo en modo entrada 

39    pinMode(PinEcho, INPUT); 

40    

41    // Inicializamos el array 

42    for (int i = 0; i < numLecturas; i++) 
43    { 

44      lecturas[i] = 0; 

45    } 

46    

47    // Configuramos las filas y las columnas del LCD en este caso 16 columnas y 2 filas 

48    lcd.begin(COLS, ROWS); 

49  } 

50  void loop() 

51  { 

52    // Eliminamos la última medida 

53    total = total ‐ lecturas[lecturaActual]; 

54    

55    iniciarTrigger(); 

56    

57    // La función pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este 
caso a HIGH 
58 
  unsigned long tiempo = pulseIn(PinEcho, HIGH); 
59 
  
60 
  // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que está en 
61 
microsegundos 
62 
  // por eso se multiplica por 0.000001 
63 
  float distancia = tiempo * 0.000001 * VelSon / 2.0; 
64 
  
65 
  // Almacenamos la distancia en el array 
66 
  lecturas[lecturaActual] = distancia; 
67 
  
68 
  // Añadimos la lectura al total 
69 
  total = total + lecturas[lecturaActual]; 
70 
  
71    // Avanzamos a la siguiente posición del array 

72    lecturaActual = lecturaActual + 1; 

73    

74    // Comprobamos si hemos llegado al final del array 

75    if (lecturaActual >= numLecturas) 

76    { 

77      primeraMedia = true; 

78      lecturaActual = 0; 

79    } 

80    

81    // Calculamos la media 

82    media = total / numLecturas; 

83    

84    // Solo mostramos si hemos calculado por lo menos una media 

85    if (primeraMedia) 

86    { 

87      float distanciaLleno = distanciaVacio ‐ media; 

88      float cantidadLiquido = distanciaLleno * 100 / distancia100; 

89      int porcentaje = (int) (distanciaLleno * 100 / distanciaVacio); 

90    

91      // Mostramos en la pantalla LCD 

92      lcd.clear(); 

93      // Cantidada de líquido 

94      lcd.setCursor(0, 0); 

95      lcd.print(String(cantidadLiquido) + " ml"); 

96    

97      // Porcentaje 

98      lcd.setCursor(0, 1); 
99      lcd.print(String(porcentaje) + " %"); 

100    

101      Serial.print(media); 

102      Serial.println(" cm"); 

103    

104      Serial.print(cantidadLiquido); 

105      Serial.println(" ml"); 

106    } 

107    else 

108    { 

109      lcd.setCursor(0, 0); 

110      lcd.print("Calculando: " + String(lecturaActual)); 

111    } 

112    

113    delay(500); 

114  } 

115    

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

117  void iniciarTrigger() 

118  { 

119    // Ponemos el Triiger en estado bajo y esperamos 2 ms 

120    digitalWrite(PinTrig, LOW); 

121    delayMicroseconds(2); 

122    

123    // Ponemos el pin Trigger a estado alto y esperamos 10 ms 

124    digitalWrite(PinTrig, HIGH); 

125    delayMicroseconds(10); 

126    
127    // 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 

Cualquier duda o sugerencia me la dejas en los comentarios de este artículo. Y con esto damos por 
terminado el tutorial donde hemos creado un sensor de nivel de agua con Arduino, si te ha 
gustado compártelo, y si tienes alguna duda deja un comentario, gracias :) 

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

Potrebbero piacerti anche