Cómo eliminar la humedad de tu casa o local: Parte 1 de 2 – Arduino

El tubo de extracción de humedad y el sensor exterior

En este tutorial explicaremos cómo deshumidificar un local en dos fases; primero detallaremos la preparación y programación de la placa Arduino con la que, mediante un relé y dos sensores DHT11 económicos, controlaremos un pequeño ventilador que hará todo el trabajo, comprobando temperaturas y humedades. Seguidamente, en una segunda entrada, nos mancharemos las manos perforando la pared y colocando un tubo de PVC con el ventilador conectado al Arduino para extraer el aire más frío y húmedo del local de la parte baja, además de colocar los sensores de humedad y la caja con Arduino, alimentación, etc. Espero que disfrutéis leyendo tanto como yo he disfrutado instalándolo; ha sido todo un éxito; la humedad de un trastero que está en contacto con la tierra ha bajado en un día del 90% al 70% de saturación (mientras en la calle había un 65%).

Introducción y preparativos

Este sistema de ventilación forzada es habitualmente utilizado cuando la ventilación natural no es suficiente, como en locales bajo tierra, con un ventilador que está permanentemente activado.

Aunque normalmente con abrir agujeros de ventilación tapadas con rejillas puede bastar para ventilar un local, al colocar un sistema de ventilación programada tendremos varias ventajas sobre este sistema: Podemos controlar las horas en que se pone en marcha, el tiempo de funcionamiento, podemos evitar que se enfríe demasiado el local o garaje (normalmente es por el día cuando la humedad baja más en la calle), además podemos colocar rejillas móviles que se abran sólo en el momento que activemos el ventilador y evitar que entre frío o calor en el recinto, aparte de que al ser ventilación forzada nos basta con poner sólo una rejilla (el aire entrará por donde pueda, es raro que el local sea totalmente hermético), etc…

Y si utilizábamos antes un deshumidificador eléctrico, el ahorro en la factura mensual de energía será importante; desde los 10€ (si se trata de uno de 200W que se pone en marcha 12 hrs diarias) para arriba, y el coste seguirá subiendo año tras año. Como os digo siempre, antes de conseguir el material necesario es importante planificar bien lo que vamos a hacer; este es un ejemplo que bien se puede llevar a otros casos con alguna modificación, casos que comentaré al final de las entradas. Necesitamos saber si utilizaremos dos sensores o sólo uno interior, si usaremos un Arduino UNO o uno Nano (más reducido y recomendado una vez que tenemos testeado el programa), etc.

Materiales para la parte de control con Arduino

• Arduino UNO Rev. 3: Puedes utilizar el Arduino que prefieras; dependiendo del tamaño que quieras dejar la caja puede servirte mejor un Arduino Nano, misma funcionalidad pero más compacto; yo he utilizado un Leonardo, pero las conexiones y funcionamiento son el mismo. Si no estás familiarizado con esta plataforma, va siendo hora que le quites el miedo, léete por ejemplo esta entrada de nuestro experto en Arduino, Isaac.
• Sensores de humedad DHT11: Es un sensor muy económico y suficientemente fiable que mide tanto humedad como temperatura. Estos que he adquirido ya llevan su circuito con la resistencia necesaria, por lo que son para conectar directamente. Dependiendo del fabricante pueden llevar el pin de datos en una u otra posición; estos en concreto tienen una S a la izda. (Salida); +5V y masa. También serán necesarios un par de conectores hembra de 3 pines para alojar los sensores, de los utilizados en los ventiladores de ordenador de 3 hilos. Antes de emplearlos es conveniente compararlos con otro sensor ya que no vienen calibrados (podremos ajustar su lectura utilizando los valores Delta en el programa).

• Relé con placa de control: Lo ideal es que, al igual que los sensores, el relé lleve ya el circuito de control (con LEDs indicadores, diodo de protección, etc), por lo que sólo necesitaremos alimentarlo a la tensión que necesite y conectarlo al pin del Arduino con el que lo activaremos, y ya lo tendremos en marcha. El que he usado yo tiene dos relés (sólo necesito uno), y funciona con 12V, pero basta con que lo alimentemos entre 7 y 12V para que se active. Podré aprovechar el mismo transformador con el que alimentaré el Arduino para alimentar el relé.

• 2 diodos LED de color verde y 1 de color rojo: En un principio iba a colocarle una pantalla indicando la humedad interior y la exterior, pero al final sólo la he utilizado para depurar el programa, por economía y sencillez, por lo que en la caja final no lleva más que tres indicadores LED que nos darán la información que necesitamos; uno rojo que se activará en caso de error de alguno de los sensores, otro verde que parpadea 2 veces por segundo para indicar que el programa está funcionando correctamente, y otro LED que se activará cuando se active el relé (para comprobar que el ventilador y relé funcionan correctamente). Para conectarlos necesitaremos al menos también una resistencia de entre 500 ohm y 1 Kohm, para que no se estropeen con los 5V de la señal digital del Arduino.
• Transformador para alimentar el Arduino y el relé: El Arduino UNO necesita entre 6 y 12V y el relé también, por lo que lo ideal es usar uno de unos 7,5V DC, suficiente para alimentar ambas cosas con el mismo. Vale cualquiera con al menos 500mA que tengas por casa de algún aparato electrónico. A mí me funciona bien con uno de 6V CC (asegúrate que entrega corriente continua y no alterna).

• Caja para circuitos eléctricos estanca: Disponible en tiendas de electricidad; no es imprescindible que sea hermetica, pero como lo voy a colocar en un local con mucha humedad y los circuitos electrónicos no se llevan bien con ella, lo menos que quiero es que se estropee el Arduino en cuanto haya cualquier problema y el ventilador deje de hacer su función. La tapa lleva una goma que dificulta que pase la humedad, y por donde pasan los cables unos prensaestopas se encargan de oprimirlos impidiendo el paso del agua y la humedad al interior.

• Termoenconladora y barras de pegamento: Qué haríamos los manitas sin este invento, que nos permite unir de forma semi-permanente nuestras piezas en cuestión de segundos, aislar cables, etc. No recomendado usarla en aquellos sitios donde la temperatura pueda subir de 60ºC, pues podría fundirse y volverse inservible.

Conexionado y programación de la placa

Veremos el programa. He tratado de hacerlo paramétrico, es decir, hay varias variables que podemos modificar a nuestro gusto para que se adapte a nuestras necesidades.

Yo he usado dos sensores de humedad, uno en el exterior y otro en el interior. Si no pudiérais colocar uno en el exterior, se puede modificar el programa para que, conociendo la humedad máxima de la calle según la zona (podemos buscar esta información en Internet), activar el ventilador cada vez que se supere dicho valor en un 5 o 10%, sería suficiente para mantener la humedad del local bajo control.

Lo primero de todo es preparar en la protoboard todos los elementos necesarios y escribir el programa y con ayuda de una pantalla o la conexión serie (yo he utilizado la pantalla LCD económica y polivalente Nokia 5110 de 84×48 píxels; tenéis en internet tutos de cómo usarla) vamos depurando su funcionamiento; no voy a entrar a explicaros cómo programar porque va más allá del objetivo de esta entrada, tenéis excelentes tutoriales en Internet. De todas formas en este tutorial os dejo el programa completo, por lo que podréis poner en marcha un sistema igual:

No os asustéis por la cantidad de cables; sin la pantalla todo es mucho más sencillo

Yo no la he usado en mi proyecto final, pero si preferís utilizar una pantalla de este tipo y evitarnos el trabajo de los LED, sólo necesitamos 5 resistencias de 2K2 ohms para conectarlo a nuestra placa, y añadir unas líneas al programa (en este enlace DHT11 con pantalla Nokia podéis descargar la versión con las librerías de la pantalla LCD que usé para depurarlo). En ella aparte de indicar los valores de temperatura y humedad, nos queda sitio para indicar si el relé está activado, y otros datos; para mí es más versátil que las pantallas de dos líneas que suelen usarse.

Esta pantalla es excelente para mostrarnos gran cantidad de información

Aquí probando un LED rojo reciclado

Tras varias pruebas el esquema definitivo se ha quedado en esto:

Utilizo una única resistencia en el lado negativo para simplificar el circuito de los LED

He reducido el voltaje que les llega a los diodos colocando una única resistencia en el negativo común; es conveniente que tenga entre 500 y 800 ohmios para alargar la vida de los LED. Por otro lado, los sensores DHT11 suelen necesitar una resistencia si es que no vienen soldados a un circuito (salen un poco más baratos) pero yo prefiero placas de sensor ya preparadas.

Para controlar fácilmente uno o varios sensores DHT11 necesitamos una librería que tendremos que descomprimir en nuestra carpeta Arduino\libraries; podéis descargárosla del siguiente enlace: DHT11 junto con el programa utilizado (en la carpeta “DHT11 Comparador”). Es la librería más compacta y sencilla que he encontrado para manipular sensores de este tipo.

El programa nos queda como sigue; se indican con el texto “Personalizable” aquellas variables que podremos ajustar a nuestras necesidades; podéis copiar el texto en el Arduino IDE donde será más fácil leerlo y entenderlo (para cualquier duda o sugerencia por favor dejar un comentario):

 //Programa para 2 sensores DHT11 de humedad y temperatura
 //cleaned by sucotronic
 //Modificado por Regata para tallerarduino.wordpress.com
 //Personalizado por Ringmaster para Comohacer.eu

// Este programa está preparado para activar el relé sólo si merece la pena, evitando consumo innecesario de energía y alargando la vida del ventilador;
 // en este caso en las horas del día más calurosas (se supone que también hay menos humedad en la calle), pero menor de XºC,
 // los valores más razonables de delta_temp y delta_hum es activarlo cuando tenemos entre un 5 y un 10% más de humedad en el interior (ajustar los valores personalizables
 // un poco según la situación), y siempre que la temperatura externa sea mayor (pero menor de XºC) activo el ventilador al menos media hora.

#include

dht11 DHT11;

#define DHT11PIN 2 //Sensor interior va al pin DIGITAL 2; indica aquí el que tú uses
 #define DHT11DOS 8 //Sensor exterior va al pin DIGITAL 8; indica aquí el que tú uses

int relePin=10; //Personalizable; Salida digital para el relé , uso la 10
 int errorPin=11; //Personalizable; Para activar el LED de error, yo uso el 11 digital
 int onPin=12; //Personalizable; Para indicar "en marcha"; pin 12 digital
 int onRele=9; //Personalizable; Para indicar que el relé está activado
 int tempint; //Variables para guardar los valores y poder comparar
 int tempext;
 int humint;
 int humext;
 int delta_temp=5; //Personalizable; Se activará cuando la temperatura exterior sea al menos este valor mayor (y parará cuando ya no haya esa diferencia)
 int delta_hum=10; //Personalizable; Se activará el relé cuando la temperatura exterior sea al menos este valor mayor (y parará cuando ya no haya esa diferencia). Yo indico 9 porque el sensor
 //exterior tiene un error del 4% menos que el interior con la misma humedad; podemos utilizar estos valores también para "calibrar" los sensores.

boolean data_error; //Guardamos el error en esta variable
 boolean rele_act=false; //Guardamos aquí si en el loop anterior se activó el relé
 long counter;
 long tiempo=30; //Personalizable; tiempo en minutos mínimo que debe activarse el relé, independientemente si baja la humedad o no; evitamos que esté arrancando y parando contínuamente.
 int tempmax=25; //Personalizable; tope temperatura exterior máxima a la que activo el relé, por si no queremos calentar demasiado el local. Indicar 99 para desactivarlo
 int temp;

void setup() {
 pinMode(relePin, OUTPUT); // sets the digital pin as output
 pinMode(errorPin, OUTPUT);
 pinMode(onPin, OUTPUT);
 pinMode(onRele, OUTPUT);
 delay(2000); //Esperamos 2 seg antes de leer los sensores
 }
 void loop() {
 data_error=false; //reseteamos el byte de comprobación
 int chk = DHT11.read(DHT11PIN);
 switch (chk){
 case DHTLIB_OK:
 //Si es OK, cogemos datos
 humint=DHT11.humidity;
 tempint=DHT11.temperature;
 break;
 //case DHTLIB_ERROR_CHECKSUM: //Desactivamos estas opciones, no nos interesan en la práctica en este caso
 // display.println("Checksum error");
 //display.display();
 //break;
 //case DHTLIB_ERROR_TIMEOUT:
 //display.println("Time out error");
 //display.display();
 //break;
 default: //en caso de cualquier otro resultado (default); error desconocido
 data_error=true; //activamos el LED de error
 break;
 }
 chk = DHT11.read(DHT11DOS); //comprobamos sensor externo
 chk=DHTLIB_OK;
 switch (chk){ //Comprobamos que los datos son válidos
 case DHTLIB_OK:
 //Si es OK cogemos los datos del externo
 humext=DHT11.humidity;
 tempext=DHT11.temperature;
 break;
 default:
 //Si no es OK, activamos el LED de error
 data_error=true;
 break;
 }
 if (data_error==true) //al menos uno de los sensores no funciona; mensaje de error y apagado de ventilador y reseteo contadores (como si se reseteara el programa)
 {
 digitalWrite(relePin, LOW);
 digitalWrite(errorPin, HIGH);
 digitalWrite(onRele, LOW);
 }
 else //si está todo ok, procedemos a comparar ambos sensores y actuar en consecuencia
 {
 digitalWrite(errorPin, LOW);

//Comparamos valores para activar o desactivar el relé
 { if (rele_act) //si el relé está activado comprobamos cada hora si merece la pena que siga en marcha
 { if (counter>0) {--counter;} //le quitamos 1 al contador sólo en caso de que sea >0
 else
 counter=tiempo;
 tempint=tempint+2; //Le añadimos un valor de margen de error (depende de la exactitud de los sensores); yo pongo 2ºC
 humext=humext+5; //Margen de error para humedad
 if (((tempext <= tempint || tempext>tempmax) & humext>=humint) || humext>=humint) //Desactivamos cuando no nos interesa la temperatura ext. o bien la humedad ext.
 {
 digitalWrite(relePin, LOW); //apagamos el ventilador y los indicadores.
 digitalWrite(onRele, LOW);
 rele_act=false;
 }
 }
 else
 {tempint=tempint+delta_temp; //le añadimos el delta de temperatura de desconexión; sólo activaremos el relé en caso de que la temp. ext sea este valor Delta mayor
 humext=humext+delta_hum; //Activar sólo cuando fuera haya al menos un {valor de Delta_hum} menos de humedad
 if ((tempext >= tempint & tempext<tempmax) || humext<=humint) //empieza a funcionar cuando la diferencia de humedad o de temp. han alcanzado el valor Delta.
 {
 digitalWrite(relePin, HIGH);
 digitalWrite(onRele, HIGH);
 rele_act=true;
 counter=tiempo; //reinicializamos el tiempo mínimo
 }
 }
 }
 }

for (int i=0; i <= 121; i++){//Hacemos parpadear el led de on durante 60 segundos (ejecutamos el bucle una vez cada 60 segundos)
 digitalWrite(onPin, HIGH); //activo led de ON
 delay(500); //Paramos medio segundo
 digitalWrite(onPin, LOW); //desactivo led de on
 }
 }
 

Como indico en los comentarios del programa, al ser un local que lidiaba con la casa a mí me interesaba activar el ventilador en las siguientes condiciones: Cuando la humedad supere un porcentaje Delta indicado, o cuando la temperatura exterior superara a la interior (pero que fuera inferior a 25ºC) para mantener el local fresco y seco, por lo que seguramente tendréis que adaptarlo un poco.

Resumiendo el funcionamiento del programa: Cada 60 segundos se obtiene el valor de los sensores; si las condiciones de activación se cumplen activamos el ventilador un tiempo mínimo; cuando acaba ese tiempo mínimo se comprueba si las condiciones siguen cumpliéndose, pero si no es así se apaga el relé, y volvemos a empezar.

Preparado el programa, es hora de comenzar a montar la caja con los diodos, Arduino y relé. En la tapa he perforado 3 pequeños agujeros justo para los diodos de estado y una vez soldados a la resistencia(s) los he fijado con termoencoladora:

Vista de la tapa donde he colocado los tres LED

Con un rotulador indeleble he marcado el significado de cada LED

Para meter tanto el Arduino (Leonardo en mi caso) en la caja junto con la placa de relés, era necesario aislar la base del circuito de relés, y nada mejor para esto que poner una capa de pegamento con la termoencoladora (se puede retirar posteriormente si fuera necesario):

No me entraba el circuito en la caja conectado al transformador, por lo que tuve que soltar el jack de la alimentación de la placa Arduino (invalidando la garantía). Siempre surge alguno de estos imprevistos… pero siempre hay una solución.

En la siguiente imagen podéis ver cómo del mismo cable de alimentación alimento tanto el relé como la placa.

Programando por última vez el Arduino antes de colocarlo en su sitio

Como la caja irá cerca del ventilador (pero a una distancia suficiente para no verse alterado por el flujo de aire), he colocado el sensor de temperatura interna pegando su base con la termoencoladora a un costado de la caja:

Conectamos todos los cables; he sacado la conexión al relé con el cable color dorado que se ve en la siguiente imagen, una vez puesta la caja atornillada a la pared este cable se encargará de activar el ventilador.

El sensor que irá al exterior tomando los valores de humedad y temperatura de la calle se puede ver a la derecha, hay que alargar esos tres cables hasta el sitio donde lo coloquemos definitivamente:

Aspecto final de la caja con todos los elementos conectados (nótese el sensor exterior a la derecha)

Finalmente lo pruebo todo antes de colocarlo en su sitio; suelto uno de los sensores y espero un minuto; ¡la luz de error se enciende por lo que todo parece ir bien!

Si os habéis dado cuenta, falta por colocar el tercer LED de estado de relé activado que coloqué posteriormente para saber si el conjunto de ventilador y relé funcionan correctamente, y que en fotos posteriores sí aparece. Sólo nos queda la prueba de fuego: Conectarlo al ventilador en su sitio y ver si todo va según lo previsto… pero eso en la próxima entrada caballeros…

Houston probando probando… Eureka!