ESCUELA SUPERIOR POLITÉCNICA DEL LITORAL

FACULTAD DE INGENIERÍA MECÁNICA Y CIENCIAS DE LA

PRODUCCIÓN

Proyecto de la materia:

DISEÑO MECATRÓNICO

Grupo #3

Participantes:
Torres Fernanda
Guevara Tiluano Aarón Gabriel
Arevalo Goyes Jonnathan Steven
Bajana Salazar Josue Abel

Tema:
Diseño de un dispositivo de monitoreo y control de la calidad de
agua para piscinas de uso recreativo

Noviembre – 2023
 a) CODIGO DE PROGRAMACION
1. #include <avr/power.h>
2.
3. //Sensores
4. int Temperatura = A0; //Pin para leer el rango de la entrada A0
5. int PH = A1; //Pin para leer el rango de la entrada A1
6. int Nivel = 8; //Pin para leer el rango de la entrada 8
7. int Cloro = A2; //Pin para leer el rango de la entrada A2
8.
9. //Controlador
10. int tempC = 7;
11. int tempI = 6;
12.
13. int phC = 5;
14. int phI = 4;
15.
16. int clC = 9;
17. int clI = 10;
18.
19. int nivelC = 3;
20. int nivelI = 2;
21.
22. //Lectores
23. int lecturaTemp; //Almacena el valor leido por el sensor de
Temperatura
24. int lecturaPH; //Almacena el valor leido por el sensor de PH
25. int lecturaCl; //Almacena el valor leido por el sensor de Cloro
26. int lecturaNivel; //Almacena el valor leido por el sensor de Nivel
27.
28. //Variables deseadas por el usuario
29. int tempDeseada = 23;
30. //int altDeseada = 170;
31.
32. //Activación del control automático.
33. int controlTemp = 0;
34. int controlPH = 0;
35. int controlCl = 1;
36.

Las primeras líneas de código son empleadas para definir las variables necesarias, de
manera general, se da una asignación de nombre a los pines de interés del Arduino, así
como sus respectivas variables de lectura de la conversión analógica, además se dan
variables para indicar si la medida está en el rango correcto o incorrecto de cada variable
de interés, también una que indique la temperatura deseada por el usuario, información

2
recogida de la aplicación planteada a usar y finalmente variables que permiten o niegan
el ingreso a los ciclos de control que veremos más adelante.

37. void setup() {

38.
39. pinMode(Temperatura, INPUT);
40. pinMode(PH, INPUT);
41. pinMode(Nivel, INPUT_PULLUP);
42. pinMode(Cloro, INPUT);
43.
44. pinMode(tempC, OUTPUT);
45. pinMode(tempI, OUTPUT);
46.
47. pinMode(phC, OUTPUT);
48. pinMode(phI, OUTPUT);
49.
50. pinMode(clC, OUTPUT);
51. pinMode(clI, OUTPUT);
52.
53. pinMode(nivelC, OUTPUT);
54. pinMode(nivelI, OUTPUT);
55.
56. //pinMode(direccionY, INPUT);
57. Serial.begin(9600);
58.
59. }
60.

En el void setup se establecen los modos en los que trabajaran los pines, sean estos
entradas o salidas y se da inicialización al monitor serial, para observar las variables
medidas.

61. void loop() {

62.
63. //Acondicionamiento de la señal de temperatura -40 - 80.
64. const float BETA = 3950; // should match the Beta Coefficient of the
thermistor
65. lecturaTemp = analogRead(Temperatura);
66. float celsius = 1 / (log(1 / (1023. / lecturaTemp - 1)) / BETA + 1.0
/ 298.15) - 273.15;
67.
68. lecturaPH = map(analogRead(PH),0,1023,0,140);
69.
70. lecturaNivel = digitalRead(Nivel);
71.
72. lecturaCl = map(analogRead(Cloro),0,1023,0,10);
73.

3
74. Serial.println("==========SENSADO==========");
75. Serial.print("Tremperatura: ");
76. Serial.println(celsius);
77. Serial.print("PH: ");
78. Serial.println(lecturaPH);
79. Serial.print("Nivel: ");
80. Serial.println(lecturaNivel);
81. Serial.print("Cloro: ");
82. Serial.println(lecturaCl);
83. Serial.println(" ");
84. delay(1000);
85.

En esta sección de void loop se entra en un bucle, donde se mapean y normalizan los
datos medidos, llevándolos a rangos más entendibles y manejables, que nos permitirán
definir las condicionales con mayor precisión. Adicional a esto, en la sección de
“===SENSADO===”, se imprime en el monitor serial, estos datos ya procesados.

86. Serial.println("==========VERIFICADO==========");
87. //Control de temperatura.
88. if(controlTemp == 1){
89. if(tempDeseada > celsius ){
90. if(celsius >= tempDeseada-2 && celsius <= tempDeseada+2){
91. Serial.println("Tremperatura Correcta");
92. digitalWrite(tempC, HIGH);
93. digitalWrite(tempI, LOW);
94. delay(50);
95. }else{
96. //Activo calefactor
97. digitalWrite(tempC, LOW);
98. digitalWrite(tempI, HIGH);
99. delay(50);
100. }
101. }else{
102. Serial.println("Tremperatura actual Mayor a la deseada");
103. }
104. }
105.
106. //Control de PH.
107. if(controlPH == 1){
108. if(lecturaPH >= 72 && lecturaPH <= 76){
109. Serial.println("PH Correcto");
110. digitalWrite(phC, HIGH);
111. digitalWrite(phI, LOW);
112. delay(50);
113. }else{
114. //Activo pastilla de cloro
115. digitalWrite(phC, LOW);

4
116. digitalWrite(phI, HIGH);
117. delay(50);
118. }
119. }
120.
121. //Control de Cloro.
122. if(controlCl == 1){
123. if(lecturaCl >= 1 && lecturaCl <= 3){
124. Serial.println("Cloro Correcto");
125. digitalWrite(clC, HIGH);
126. digitalWrite(clI, LOW);
127. delay(50);
128. }else{
129. //Activo pastilla de cloro
130. digitalWrite(clC, LOW);
131. digitalWrite(clI, HIGH);
132. delay(50);
133. }
134. }
135.
136. //Control de Nivel.
137. if(lecturaNivel == LOW){
138. Serial.println("Nivel Correcto");
139. digitalWrite(nivelC, HIGH);
140. digitalWrite(nivelI, LOW);
141. delay(50);
142. delay(50);
143. }else{
144. //Activo válvula
145. digitalWrite(nivelC, LOW);
146. digitalWrite(nivelI, HIGH);
147. delay(50);
148. }
149. Serial.println(" ");
150. delay(1000);
151.
152. }

Finalmente se establece en la sección de “===VERIFICADO===” los condicionales

respectivos a cada variable de interés, para cada control a realizar, definiendo los rangos

5
con sus respectivas tolerancias y las acciones a realizarse en caso de que nos
encontremos dentro del rango deseado o fuera de este.

b) SIMULACION
Para la simulación fueron empleados LEDS, de diversos colores que simulen bobinas
activas, es decir que estos están como reemplazos del actuador que se empleará en un
diseño posterior del sistema. Y se emplean potenciómetros que simulan las entradas
analógicas de los sensores no encontrados en el simulador empleado.

Para una temperatura medida de 22℃:

Se encenderá un LED amarillo, que indica que la temperatura actual es igual a la deseada con
una tolerancia de ±2℃, podemos observar en el monitor serial como indica que la temperatura
es la correcta, además de los valores obtenidos para las otras variables de interés, las cuales
están fuera del rango deseado y por eso existen LEDS rojos encendidos, uno por cada variable
no adecuada.

6
También podemos observar que ocurre cuando se desactiva el control automático de una de las
variables de interés, en este caso la temperatura, ambos LEDS, se desactivas, y si bien el valor
obtenido de temperatura está dentro del rango deseado, no se muestra un mensaje, ya que el
control no se está llevando a cabo. Adicional, el PH ahora se encuentra en el rango adecuado,
esto una vez que se haya regulado con el actuador adecuado y por eso el LED verde se enciende,
apagándose el LED rojo adyacente. Las demás variables están iguales.

En esta ocasión se desactiva el control automático del PH, apagándose ambos LEDS
relacionados. Además, el botón representa la entrada digital dada por un sensor de nivel, en
este caso el sensor indicaría si nos encontramos en el nivel deseado o no, y en caso de estarlo
(Como en la imagen) se activa el LED azul, y se apaga el rojo adyacente, mostrando en el monitor
serial que el nivel de agua es el adecuado. Además, es observable que el LED verde se encuentra
encendido, y su adyacente apagado, esto simulando que el sensor de cloro detecta que nos
encontramos en el rango deseado.

7
Como fue mencionado estos LEDS representan apagados y encendidos de bobinas, que
activaran actuadores, como lo son un calefactor, un aparato que solventa de cloro líquido y una
boya, para los sensores de temperatura, PH – Cloro y nivel respectivamente.
Encendiéndose/activándose solo en caso de que el sensor lo indique.

c) CONCLUSIONES
• Observamos que requerimos actuadores, tal vez, demasiado específicos para las tareas
propuestas del sistema, de modo que podría existir problemas al momento de trabajar
con el actuador real.

• Para el diseño final del sistema podrían mantenerse los LEDS indicadores de sí el sistema
se encuentra funcionando correctamente, o existe algún problema interno o de usuario
sucediendo en algún instante.

• Podría haber problemas de falta de corriente o de alimentación, ya que se están

empleando demasiados elementos externos y todos se encuentran conectados al
Arduino.