Sie sind auf Seite 1von 17

Medicin de Nivel con Arduino 1

Cuando trabajo con Arduino, una de las cosas que ms me gusta es poder crear dispositivos o
aplicaciones como si estuviera jugando con un LEGO o Tente. Es increble las posibilidades que
nos brinda el Open Hardware. En este artculo vamos a ver un ejemplo de cmo podemos crear
un sensor de nivel de agua con Arduino. Cuando hablo de agua puede ser cualquier lquido e
incluso sustancias slidas. Lo nico que debemos de tener en cuenta es la capacidad del
recipiente.

Una de las formas ms sencillas es utilizar el sensor de ultrasonidos. Ya he hablado en algn otro
artculo de este sensor. Veremos las caractersticas principales para utilizarlo con Arduino. El otro
componente ser una pantalla LCD. Aqu es donde visualizaremos en todo momento la cantidad
de agua o lquido que queda en el recipiente. La aplicacin es sencilla, con el sensor de
ultrasonidos mediremos cuanta distancia hay hasta el lquido. Debemos conocer el recipiente para
saber cunta cantidad cabe y que medida se obtiene cuando est lleno. Lo mismo haremos
cuando el recipiente est vaco. Esto se llama calibracin. La pantalla LCD nos mostrar el
porcentaje de lquido que nos queda en el recipiente y su equivalente en litros. En este proyecto
haremos uso de las matemticas a nivel bsico y de la programacin a un nivel medio. Te lo ir
explicando todo paso a paso para que quede todo bien claro.

ndice de contenidos

1 El sensor de nivel de agua con Arduino nos permite medir cualquier lquido gracias al
sensor de ultrasonidos.
2 Componentes necesarios para el sensor de nivel de agua con Arduino
3 Circuito elctrico
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 lquido gracias al
sensor de ultrasonidos.
La pieza ms importante en este proyecto ser el Arduino. En este caso podemos utilizar
cualquier modelo que tenga como mnimo 8 entradas digitales. En este tutorial trabajar con la
placa ms famosa de Arduino, la UNO.

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

1. Circuito elctrico, conectando los componentes


2. Probar todos los componentes y conexiones
3. Montando el sensor en la cubeta
4. Calibrando el sensor de nivel de agua con Arduino
5. Mostrando los datos en el LCD
6. 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 continuacin, alguno es prescindible.
Arduino UNO

Ser el cerebro de la aplicacin y el encargado de gestionar todos los sensores a travs de las
entradas y salidas digitales. En la programacin reside su potencia. Veremos que cdigo debemos
implementar para poder medir el nivel en un recipiente.

Sensor ultrasonidos HC-SR04

Ya hemos visto en diferentes artculos e incluso un captulo del podcast cmo 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 ultrasnica desde que sale del sensor
hasta que regresa.

Gracias a este tiempo y sabiendo la velocidad del sonido, es fcil calcular la distancia aplicando la
famosa frmula.

Pantalla LCD 162

Este componente tambin lo hemos visto en varios artculos. Mostrando texto en


movimiento y mostrando la temperatura de un sensor. Consiste en una pantalla de cristal lquido
de 16 columnas y 2 filas. En ella iremos escribiendo los resultados obtenidos de las mediciones
as como alguna otra informacin til en este proyecto.

Dems componentes electrnicos

Adems de los componentes esenciales para el sensor de nivel de agua con Arduino, vamos a
necesitar los tpicos componentes que se suelen utilizar en muchos circuitos. Te los detallo a
continuacin.
Protoboard
Potencimetro 10k
Resistencia 220
Cables

Circuito elctrico

Con todos los componentes en nuestro poder, ya podemos empezar a montar el circuito. Como ya
he comentado al principio del artculo, vamos a necesitar 8 entradas y salidas digitales. Adems
utilizaremos el pin de 5V y el GND (toma de tierra). El circuito sera 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 elctrico. Es importante asegurarnos de
que todo est bien conectado. Lo ms 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 ms 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.

1 // Configuramos los pines del sensor Trigger y Echo

2 const int PinTrig = 7;

3 const int PinEcho = 6;

5 // Constante velocidad sonido en cm/s

6 const float VelSon = 34000.0;

8 float distancia;

10 void setup()

11 {

12 // Iniciamos el monitor serie para mostrar el resultado

13 Serial.begin(9600);

14 // Ponemos el pin Trig en modo salida


15 pinMode(PinTrig, OUTPUT);

16 // Ponemos el pin Echo en modo entrada

17 pinMode(PinEcho, INPUT);

18 }

19 void loop()

20 {

21 iniciarTrigger();

22

23 // La funcin pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este caso a HIGH

24 unsigned long tiempo = pulseIn(PinEcho, HIGH);

25

26 // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que est en microsegundos

27 // por eso se multiplica por 0.000001

28 distancia = tiempo * 0.000001 * VelSon / 2.0;

29 Serial.print(distancia);

30 Serial.print("cm");

31 Serial.println();

32 delay(500);

33 }

34

35 // Mtodo que inicia la secuencia del Trigger para comenzar a medir

36 void iniciarTrigger()

37 {

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

39 digitalWrite(PinTrig, LOW);

40 delayMicroseconds(2);

41

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

43 digitalWrite(PinTrig, HIGH);

44 delayMicroseconds(10);

45

46 // Comenzamos poniendo el pin Trigger en estado bajo

47 digitalWrite(PinTrig, LOW);

48 }

En el monitor serie debe aparecer algo parecido a lo siguiente.


Si el resultado es siempre 0 cm, debes comprobar las conexiones que estn todas correctas
segn 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.

1 // Incluimos la librera externa para poder utilizarla

2 #include <LiquidCrystal.h> // Entre los smbolos <> buscar en la carpeta de libreras configurada

4 // Lo primero is inicializar la librera indicando los pins de la interfaz

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

7 // Definimos las constantes

8 #define COLS 16 // Columnas del LCD

9 #define ROWS 2 // Filas del LCD

10

11 void setup() {

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

13 lcd.begin(COLS, ROWS);

14 }

15

16 void loop() {

17
18 lcd.setCursor(0,0);

19 lcd.print("Hola Mundo!!!!!!");

20 lcd.setCursor(0,1);

21 lcd.print("Probando el LCD.");

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 lquido. 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 tpicos para saber si el bizcocho est hecho o para
hacer brochetas.

Adems, he utilizado dos alambres de los tpicos 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 imgenes.

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 cmo quedara.

Esto tambin nos puede servir de sujecin con alguna goma elstica u otro mtodo 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 lquido. Esto nos permitir saber qu cantidad de lquido tenemos en el recipiente.
Algo que tienes que tener en cuenta es que el sensor de ultrasonidos mide la cantidad de espacio
vaco en el recipiente. Por lo tanto, si conocemos la capacidad total del recipiente, al restar la
cantidad de espacio vaco sabremos cunto lquido hay. Mira el esquema general.

Entonces, segn este esquema general debemos conocer que valor obtenemos con el sensor de
ultrasonidos cuando est vaco, 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 cilndrico
es decir, la base debe ser del mismo dimetro que la parte de arriba. Si intentamos medir en un
recipiente que no es cilndrico, en forma de cono, las medidas no sern proporcionales.

Calcular la media para eliminar el ruido

En todos los sistemas electrnicos se genera un ruido debido al movimiento de los electrones, al
propio sensor, la placa de Arduino, etc Esto se traduce en una variacin o fluctuacin en las
medidas que vamos obteniendo a travs 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 ms sencilla de aplicarlo a travs de la programacin 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. Imagnate un depsito 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 sera complicado si no se utiliza alguna tcnica como esta.

Dependiendo del nmero de muestras que utilicemos para obtener la media, podremos tener un
valor ms preciso o menos preciso. Pero esto tambin influye en cunto tarda en estabilizarse la
medida cuando se produce un cambio. Por lo tanto, si cogemos un nmero alto de muestras, la
media ser ms precisa pero tardar ms tiempo en reflejar los cambios. Por el contrario, si
cogemos un nmero bajo de muestras, la media ser menos precisa pero veremos reflejados ms
rpidos los cambios. Elegir uno u otro depender de lo que queramos conseguir, rapidez o
precisin.

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

En este caso yo voy a elegir precisin, voy a coger un rango de muestras de 100. El cdigo es
muy parecido al que hemos utilizado para probar el sensor de ultrasonidos al que he aadido el
clculo de la media cada 100 valores. No voy a profundizar ms en esta tcnica, si quieres
aprender todo lo que hay detrs te aconsejo que veas la leccin donde muestro como estabilizar
el sensor de temperatura LM35.
El cdigo que debes cargar en tu placa es el siguiente

1 // Configuramos los pines del sensor Trigger y Echo

2 const int PinTrig = 7;

3 const int PinEcho = 6;

5 // Constante velocidad sonido en cm/s

6 const float VelSon = 34000.0;

8 // Nmero 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 funcin 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 microsegundos

43 // por eso se multiplica por 0.000001

44 float distancia = tiempo * 0.000001 * VelSon / 2.0;

45

46 // Almacenamos la distancia en el array

47 lecturas[lecturaActual] = distancia;

48

49 // Aadimos la lectura al total

50 total = total + lecturas[lecturaActual];

51

52 // Avanzamos a la siguiente posicin del array

53 lecturaActual = lecturaActual + 1;

54

55 // Comprobamos si hemos llegado al final del array

56 if (lecturaActual >= numLecturas)

57 {

58 primeraMedia = true;

59 lecturaActual = 0;

60 }

61

62 // Calculamos la media

63 media = total / numLecturas;

64

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

66 if (primeraMedia)

67 {

68 Serial.print(media);

69 Serial.println("cm");

70 }

71

72 delay(500);
73 }

74

75 // Mtodo que inicia la secuencia del Trigger para comenzar a medir

76 void iniciarTrigger()

77 {

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

79 digitalWrite(PinTrig, LOW);

80 delayMicroseconds(2);

81

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

83 digitalWrite(PinTrig, HIGH);

84 delayMicroseconds(10);

85

86 // Comenzamos poniendo el pin Trigger en estado bajo

87 digitalWrite(PinTrig, LOW);

88 }

Estos son los datos que yo he obtenido, seguramente tu hayas obtenido otros valores, depender
del recipiente y de la cantidad de lquido que entre en dicho recipiente.

VACO LLENO 100 ML

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

Calculando el nivel de lquido

Con los datos obtenidos en la fase anterior, con el recipiente en vaco, lleno y con 100 ml, ya
podemos obtener una frmula para el sensor de nivel de agua con Arduino. Las medidas
obtenidas nos indican la cantidad de espacio vaco 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 lquido
estuviera a 0 cm cuando el recipiente est cero.

VACO 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 cunto ocupa 100 ml de lquido en nuestro recipiente. Esto se hace
restando la distancia cuando est vaco menos la distancia cuando tiene 100 ml.

Esta medida nos dice que cada 2,15 cm hay 100 ml de lquido. Con esto ya es sencillo calcular
cunto lquido 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 sera el espacio vaco pero
nosotros queremos saber cunto espacio queda lleno. Lo calculamos restando la distancia en
vaco menos la distancia obtenida.
Como sabemos que cada 2,15 cm hay 100 ml, aplicando una simple regla de 3 sabremos la
cantidad de lquido que tenemos.

Pues ya tenemos la base matemtica para calcular el nivel de lquido en nuestro recipiente, ahora
solo nos queda aplicar dichos clculos en nuestro sketch.

Programando el sketch para calcular el nivel

Todo esto tenemos que plasmarlo en un sketch para subirlo a nuestro Arduino. A continuacin te
dejo el cdigo para que veas como lo he hecho. Fjate en los comentarios.

1 // Configuramos los pines del sensor Trigger y Echo

2 const int PinTrig = 7;

3 const int PinEcho = 6;

5 // Constante velocidad sonido en cm/s

6 const float VelSon = 34000.0;

8 // Nmero de muestras

9 const int numLecturas = 100;

10

11 // Distancia a los 100 ml y vaco

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 funcin 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 microsegundos

47 // por eso se multiplica por 0.000001

48 float distancia = tiempo * 0.000001 * VelSon / 2.0;

49

50 // Almacenamos la distancia en el array

51 lecturas[lecturaActual] = distancia;

52

53 // Aadimos la lectura al total

54 total = total + lecturas[lecturaActual];

55

56 // Avanzamos a la siguiente posicin del array

57 lecturaActual = lecturaActual + 1;

58

59 // Comprobamos si hemos llegado al final del array

60 if (lecturaActual >= numLecturas)

61 {

62 primeraMedia = true;

63 lecturaActual = 0;
64 }

65

66 // Calculamos la media

67 media = total / numLecturas;

68

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

70 if (primeraMedia)

71 {

72 float distanciaLleno = distanciaVacio - media;

73 float cantidadLiquido = distanciaLleno * 100 / distancia100;

74

75 Serial.print(media);

76 Serial.println(" cm");

77

78 Serial.print(cantidadLiquido);

79 Serial.println(" ml");

80 }

81

82 delay(500);

83 }

84

85 // Mtodo que inicia la secuencia del Trigger para comenzar a medir

86 void iniciarTrigger()

87 {

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

89 digitalWrite(PinTrig, LOW);

90 delayMicroseconds(2);

91

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

93 digitalWrite(PinTrig, HIGH);

94 delayMicroseconds(10);

95

96 // Comenzamos poniendo el pin Trigger en estado bajo

97 digitalWrite(PinTrig, LOW);

98 }
Mostrando los datos en el LCD

Por ltimo y, aunque no es necesario, vamos a mostrar la informacin en una pantalla LCD de
162. La informacin que vamos a mostrar es la cantidad de lquido en ml y el porcentaje de
llenado. Estos datos son fundamentales en el sensor de nivel de agua con Arduino.

El siguiente cdigo lo nico que hago es mezclar el cdigo anterior donde obtenemos la cantidad
de lquido y el cdigo con el que hemos probado el LCD.

1 // Inclumos la libreria externa para poder utilizarla

2 #include <LiquidCrystal.h> // Entre los smbolos <> buscar en la carpeta de libreras configurada

4 // Lo primero is inicializar la librera indicando los pins de la interfaz

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

7 // Definimos las constantes

8 #define COLS 16 // Columnas del LCD

9 #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 // Constante velocidad sonido en cm/s

16 const float VelSon = 34000.0;

17

18 // Nmero de muestras

19 const int numLecturas = 100;

20

21 // Distancia a los 100 ml y vaco

22 const float distancia100 = 2.15;

23 const float distanciaVacio = 11.41;

24

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

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

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

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

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

30
31 void setup()

32 {

33 // Iniciamos el monitor serie para mostrar el resultado

34 Serial.begin(9600);

35 // Ponemos el pin Trig en modo salida

36 pinMode(PinTrig, OUTPUT);

37 // Ponemos el pin Echo en modo entrada

38 pinMode(PinEcho, INPUT);

39

40 // Inicializamos el array

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

42 {

43 lecturas[i] = 0;

44 }

45

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

47 lcd.begin(COLS, ROWS);

48 }

49 void loop()

50 {

51 // Eliminamos la ltima medida

52 total = total - lecturas[lecturaActual];

53

54 iniciarTrigger();

55

56 // La funcin pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este caso a HIGH

57 unsigned long tiempo = pulseIn(PinEcho, HIGH);

58

59 // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que est en microsegundos

60 // por eso se multiplica por 0.000001

61 float distancia = tiempo * 0.000001 * VelSon / 2.0;

62

63 // Almacenamos la distancia en el array

64 lecturas[lecturaActual] = distancia;

65

66 // Aadimos la lectura al total

67 total = total + lecturas[lecturaActual];


68

69 // Avanzamos a la siguiente posicin del array

70 lecturaActual = lecturaActual + 1;

71

72 // Comprobamos si hemos llegado al final del array

73 if (lecturaActual >= numLecturas)

74 {

75 primeraMedia = true;

76 lecturaActual = 0;

77 }

78

79 // Calculamos la media

80 media = total / numLecturas;

81

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

83 if (primeraMedia)

84 {

85 float distanciaLleno = distanciaVacio - media;

86 float cantidadLiquido = distanciaLleno * 100 / distancia100;

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

88

89 // Mostramos en la pantalla LCD

90 lcd.clear();

91 // Cantidada de lquido

92 lcd.setCursor(0, 0);

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

94

95 // Porcentaje

96 lcd.setCursor(0, 1);

97 lcd.print(String(porcentaje) + " %");

98

99 Serial.print(media);

100 Serial.println(" cm");

101

102 Serial.print(cantidadLiquido);

103 Serial.println(" ml");

104 }
105 else

106 {

107 lcd.setCursor(0, 0);

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

109 }

110

111 delay(500);

112 }

113

114 // Mtodo que inicia la secuencia del Trigger para comenzar a medir

115 void iniciarTrigger()

116 {

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

118 digitalWrite(PinTrig, LOW);

119 delayMicroseconds(2);

120

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

122 digitalWrite(PinTrig, HIGH);

123 delayMicroseconds(10);

124

125 // Comenzamos poniendo el pin Trigger en estado bajo

126 digitalWrite(PinTrig, LOW);

127 }

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 programacin ni de imaginacin, 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 podras aplicar mejoras para que puedas utilizarlo en ambientes donde se
exija mayor precisin y estabilidad.

Utilizar un sensor de ultrasonidos ms 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 artculo. Y con esto damos
por terminado el tutorial donde hemos creado un sensor de nivel de agua con Arduino, si te ha
gustado comprtelo, y si tienes alguna duda deja un comentario, gracias :)