VENTILADOR AUTOMATICO

La base para un sistema de control donde un ventilador de

encendido automático por temperatura se encarga de
mantener un ambiente fresco, eliminando el calor
automáticamente cuando este supere los niveles establecidos
por el usuario
En este post se explica cómo  controlar el encendido y apagado de un
ventilador de forma automática, mediante Arduino UNO y un sensor
DTH11, el cual registra datos de temperatura y humedad.

En este blog ya antes se había hablado de este sensor

 DHT11: Sensor de humedad/temperatura para Arduino

Para esta experiencia se utilizará solamente datos de temperatura.

Para llevar a cabo la experiencia utilizaremos los siguientes

materiales:

  Batería de 9 V       Ventilador de 12 V

 2 leds (verde y rojo)     2 resistencias de 330 Ω

 1 resistencia de 1k Ω       Un Arduino UNO

 Transistor C2073       Sensor DTH11

      Jumpers       Protoboard

Resulta que el ventilador que se va a utilizar utiliza para su

funcionamiento 12 voltios y consume 140 mA. Arduino solamente puede
proporcionar 5 voltios y 40 mA, por lo que es necesario utilizar un
dispositivo de control para Arduino, en este caso, un transistor NPN del
cual ya se ha hablado antes:

 Herramientas de control para Arduino: El BJT o Transistor de

Unión Bipolar (NPN y PNP)

Veamos las conexiones que se deben hacer:

LED1=Rojo                                                                                                  
LED2= Verde

R1= 330 Ω                                               R2= 330 Ω                                 R3= 1k

Ω

Cabe resaltar que utilizamos un motor para realizar una representación del
ventilador.

Ahora vamos a la programación. Abrimos Arduino IDE y copiamos las

siguientes instrucciones:

#include "DHT.h"

#define DHTPIN 2 
#define DHTTYPE DHT11 

DHT dht(DHTPIN, DHTTYPE);

int Temp=32; //Parámetro de encendido de ventilador

void setup() {

  Serial.begin(9600);

  dht.begin();

  pinMode(8,OUTPUT);

  pinMode(9,OUTPUT);

  pinMode(10,OUTPUT);

void loop() {

  float t = dht.readTemperature();

  //Serial.println("Temperatura: "); Se imprimen las variables

  //Serial.println(t); Quitar comentarios si desea imprimir la temperatura

  if (t >=Temp){

    digitalWrite(8,HIGH);

    digitalWrite(9,HIGH);

    digitalWrite(10,LOW);

  }

  if(t < Temp){

    digitalWrite(8,LOW);

    digitalWrite(9,LOW);

    digitalWrite(10,HIGH);
  }

  delay(3000);

Estas instrucciones nos permiten utilizar el sensor DTH11, para registrar

datos de temperatura, Los parámetros que se establezcan harán posible
que se controle el funcionamiento del ventilador.

El sensor registra la temperatura cada 3 segundos. Si la temperatura es

mayor o igual a 32 °C  el led rojo se enciende  en señal de alerta y el
ventilador empieza a funcionar de manera automática. De otro modo si
la temperatura registrada es menor de 32 °C el led verde se enciende
indicando que la temperatura es la adecuada en ese momento.

A continuación algunas imágenes del circuito armado en un protoboard:

 
Espero que esta información sea de gran utilidad para ustedes.

El DHT11 es un sensor de humedad/temperatura de bajo

costo y de media precisión, muy útil para los principiantes en
el mundo de Arduino
Nota:  Si se desea utilizar un sensor de humedad/temperatura de alta
precisión recomiendo consultar el  DHT22, parecido al DHT11 pero mucho
más preciso.

En esta ocasión escribiré acerca del DHT11 que es un sensor de

temperatura muy económico y muy utilizado por los amantes de la
electrónica y los microcontroladores como Arduino.
El DHT11 es un sensor que proporciona una salida de datos digital. Entre
sus ventajas podemos mencionar el bajo coste y el despliegue de datos
digitales. Esto supone una gran ventaja frente a los sensores del tipo
análogo, como el LM335 por ejemplo, en los cuales las fluctuaciones en
el voltaje alteran la lectura de datos.

Entre las desventajas pues, el DHT11 solo lee enteros, no podemos leer
temperaturas con decimales por lo que tenemos que pensarlo muy bien
a la hora de utilizar este sensor para trabajos en los que se requieran
lecturas precisas de temperatura y/o humedad. En fin, vamos a lo que
vamos. Para poder leer datos desde este sensor de una forma sencilla
necesitamos descargar una librería que ha sido escrita para este
propósito.

Hay tutoriales que explican como leer este sensor sin dicha librería, sin
embargo el tema es bastante complicado para alguien que no esté
acostumbrado a programar. Se necesita leer una onda cuadrada en la
cual se envían los bits con separaciones de unos cuantos
microsegundos. La verdad prefiero usar la librería DHT11.

Primero descargamos los archivos que conforman esta librería. Los

podemos encontrar aquí. Ahora que hemos descargado, nos vamos a la
carpeta de nuestro Arduino IDE, buscamos una carpeta
llamada “libraries” y ahí descomprimimos el archivo *.rar. Nos debe
quedar así:

Ahora abrimos Arduino IDE y pegamos el siguiente código:

#include "DHT.h" //cargamos la librería DHT

#define DHTPIN 2 //Seleccionamos el pin en el que se //conectará el

sensor

#define DHTTYPE DHT11 //Se selecciona el DHT11 (hay //otros DHT)

DHT dht(DHTPIN, DHTTYPE); //Se inicia una variable que será usada por

Arduino para comunicarse con el sensor

void setup() {

Serial.begin(9600); //Se inicia la comunicación serial

dht.begin(); //Se inicia el sensor

void loop() {

float h = dht.readHumidity(); //Se lee la humedad

float t = dht.readTemperature(); //Se lee la temperatura

//Se imprimen las variables

Serial.println("Humedad: ");

Serial.println(h);

Serial.println("Temperatura: ");

Serial.println(t);

delay(2000); //Se espera 2 segundos para seguir leyendo //datos

Como podemos observar, no es difícil obtener lecturas de humedad y

temperatura con este sensor. Ahora solo necesitamos conectarlo a
Arduino e iniciar la lectura de datos.

El GND y el VCC del sensor se conectan en sus correspondientes pines

en Arduino (GND y +5V, respectivamente). El pin “data” se conecta al pin
2, que ya declaramos en el código.

.
Cuando subamos el código al micro, vamos al Monitor Serial y
obtenemos el siguiente resultado:
Cada 2 segundos obtendremos una nueva lectura.
Herramientas de control para Arduino: El
BJT o Transistor de Unión Bipolar (NPN y
PNP)

Una breve reseña sobre lo que es el transistor BJT, tanto el NPN como
el PNP y los usos que le podemos dar a estos dispositivos con nuestro
Arduino, como una herramienta potenciadora de las capacidades de
corriente y voltaje de nuestro microcontrolador.

Hace algún tiempo escribí un post sobre el BJT y su uso en la electrónica.

Se los recomiento para que comprendan un poco acerca de qué es el
transistor BJT y los distintos tipos que existen. Existen 2 tipos de
transistores: el transistor NPN y el PNP.

Son visualmente idénticos pero su comportamiento varía un poco. En

esquemas eléctricos, se representan por los siguientes símbolos:
El funcionamiento es el siguiente:

Transistor NPN
El colector del transistor se coloca a una carga, por ejemplo un LED. El
emisor se coloca a GND. Cuando se aplique voltaje a la base, se creará
un puente entre el emisor y el colector, haciendo que la carga quede
conectada a GND y se cierre el cieruito. Veamos:
Como vemos, cuando se aplica un voltaje a la base, el “switch” se cierra.
Nótese que en la base sólo se aplican 5 voltios, pero el LED está
funcionando con 9 voltios. Esto quiere decir que se pueden manipular
tensiones mucho mayores a las soportadas por algún dispositivo de
control (como Arduino) con solo un pequeño pulso.

Transistor PNP
Funciona casi como el transistor NPN, sin embargo se conecta entre la
fuente de poder y la carga, no entre la carga y el GND como el transistor
NPN. Veamos:
Lo que haremos es encender un LED utilizando un transistor NPN. En el
siguiente video se muestra el funcionamiento del BJT y su posterior
implementación con Arduino.

Funcionan perfectamente igual, pero se utilizan de manera

diferente. Los transistores generalmente necesitan ser colocados en un
disipador de calor.

Cuando se aplica voltaje a la base

del BJT y se cierra el circuito, se dice que el transistor está en estado de
“saturación”.  Al entrar en saturación se produce un movimiento de
electrones desde el colector hasta el emisor del transistor. Dicho
movimiento de electrones produce calor, el cual podría llegar a fundir el
transistor. Por eso se suele atornillar el transistor a un disipador para
que el calor se disipe en el aire.

Funcionamiento del Transistor de Unión Bipolar

Haremos unas pruebas con un transistor de unión bipolar, un transistor
NPN.

Necesitamos los siguientes materiales:

 Transistor NPN
 LEDs

 Resistencias de 330 Ohm y 1 KOhm

  Un protoboard

Lo que haremos es encender un LED utilizando un transistor NPN. En el

siguiente video se muestra el funcionamiento del BJT y su posterior
implementación con Arduino.
2

Tutorial Arduino III. Sensores DHT y Display LCD

En este tutorial de Arduino vamos a medir la temperatura ambiente y el
nivel de humedad relativa con un sensor digital de la familia DHT, en
concreto el DHT22, y mostrarla en un display LCD de 16x2, de esta forma
podemos familiarizarnos con el manejo de sensores digitales. El tutorial es
válido para cualquier sensor de esta familia. Las ventajas de estos frente a
los analógicos son dos: por un lado el nivel de precisión y rango de medida
son superiores en los digitales (dejando a parte los termopares), además los
sensores analógicos al enviar una lectura en forma de voltaje, no deben
utilizarse con largas tiradas de cable, sino que deben estar físicamente
cerca de la placa que recibe la lectura para evitar perdidas, lo que limita
sus aplicaciones practicas. Este inconveniente no se da en los sensores
digitales, por razones obvias.

La familia de sensores ambientales DHT esta formada por tres

modelos: DHT11,DHT21 y DHT22, estos dos últimos se presentan en dos
versiones diferentes, la básica, para soldar o pinchar directamente en
protoboard y la encapsulada y cableada, mucho más práctica que es la
podéis encontrar en nuestra tienda.

JUN

29

Tutorial Arduino III. Sensores DHT y Display LCD

En este tutorial de Arduino vamos a medir la temperatura ambiente y el
nivel de humedad relativa con un sensor digital de la familia DHT, en
concreto el DHT22, y mostrarla en un display LCD de 16x2, de esta forma
podemos familiarizarnos con el manejo de sensores digitales. El tutorial es
válido para cualquier sensor de esta familia. Las ventajas de estos frente a
los analógicos son dos: por un lado el nivel de precisión y rango de medida
son superiores en los digitales (dejando a parte los termopares), además los
sensores analógicos al enviar una lectura en forma de voltaje, no deben
utilizarse con largas tiradas de cable, sino que deben estar físicamente
cerca de la placa que recibe la lectura para evitar perdidas, lo que limita
sus aplicaciones practicas. Este inconveniente no se da en los sensores
digitales, por razones obvias.
La familia de sensores ambientales DHT esta formada por tres
modelos: DHT11,DHT21 y DHT22, estos dos últimos se presentan en dos
versiones diferentes, la básica, para soldar o pinchar directamente en
protoboard y la encapsulada y cableada, mucho más práctica que es la
podéis encontrar en nuestra tienda.

Las características generales de estos sensores son (el DHT22 es una

evolución del DHT21 con unas prestaciones muy similares):
 La estructura para la conexión de estos sensores es la misma en todos los
modelos, un pin para la alimentación, otro para el GND y otro para datos. El
cuarto pin es para la función "disconected" que rara vez se utiliza, de hecho
en las versiones encapsuladas (como la que vamos a usar) si bien el pin
esta presente no esta cableado, por lo que solo habrá tres cables: el rojo
(alimentación), negro (GND) y amarillo (datos).

Material Necesario

El material necesario para la realización de este tutorial consiste en:

1. Arduino Uno
2. Breadboard con Puentes de Conexion
3. Sensor de Temperatura DHT22
4. Display LCD 16x2 LMB162HBC
5. Resistencia variable de 10K Ohm
6. Resistencia 1/4w 10K Ohm
7. Tira de 40 Pines Macho
 Esquema de Montaje

Los datasheet del sensor DHT22 y del Display LCD son:

1. Datasheet Sensor DHT22

2. Datasheet Display LCD LMB162HBC

El esquema de montaje en Fritzing de todos los componentes y las

conexiones necesarias es el siguiente:

En lo que se refiere al conexionado del Display LCD es el mismo que usamos

en el anterior Tutorial Arduino: Sensor TMP36 y Display LCD, que repetimos:
 Salida 5V del Arduino al positivo de la Breadboard 
 GND del Arduino al GND de la Breadboard 
 Un pin del potenciometro de 10K Ohm al positivo de la Breadboard 
 Pin central del potenciometro de 10K Ohm al GND de la Breadboard 
 El tercer pin del potenciometro de 10K Ohm al pin 3 del LCD (V0) 
 Pin 15 LCD  (BLA) al positivo de la breadboard  
 Pin 16 LCD (BLK) al GND de la breadboard  
 Pin 1 LCD (VSS) al GND de la Breadboard  
 Pin 2 LCD  (VDD) al positivo de la Breadboard
 Pin 4 LCD (RS) a la salida 7 del Arduino  
 Pin 5 LCD (R/W) al GND de la Breadboard 
 Pin 6 LCD (E) a la salida 8 del Arduino 
 Pin 11 LCD (DB4) a la salida 9 del Arduino 
 Pin 12 LCD (DB5) a la salida 10 del Arduino 
 Pin 13 LCD (DB6) a la salida 11 del Arduino 
 Pin 14 LCD (DB7) a la salida 12 del Arduino 

La resistencia variable de 10K Ohm se utiliza para regular el contraste del

display LCD por lo que para ver los datos que enviemos al mismo hay que
ajustarlo manualmente mediante un eje o un pequeño destornillador.

En lo que respecta al sensor DHT22, en nuestra versión encapsulada y

cableada, tenemos tres cables, el rojo para la alimentación, el negro para el
GND y el amarillo para datos conectado en nuestro ejemplo al pin 2 de
Arduino. La única particularidad es que montamos una resistencia "pull-up"
de 10K Ohm que conecta el voltaje con el pin de datos.

Sketch Arduino

Para el uso de este sensor, como en otros muchos casos, es necesario

instalar de forma previa la librería correspondiente, sino se esta
familiarizado con este proceso resultar interesante leer nuestro Tutorial
Arduino II: Librerias Arduino.
Podéis descargar la librería necesaria aquí: Librería Sensores DHT.

El sketch para mostrar los datos de temperatura y humedad relativa en el

display LCD es:

#include <LiquidCrystal.h> 
//Llamamos a la libreria para controlar el LCD incluida en el IDE de A
rduino
LiquidCrystal lcd(7, 8, 9, 10, 11 , 12); 
//Definimos los pines asignados al LCD según el esquema de conexión
#include "DHT.h"
//Llamamos a la libreria de los sensores DHT instalada previamente
#define DHTPIN 2 
#define DHTTYPE DHT22
//Definimos el pin de Arduino al que conectamos el pin de datos del s
ensor e indicamos el tipo de sensor (DHT22)

DHT dht(DHTPIN, DHTTYPE);

void setup(){
  Serial.begin(9600);
  Serial.println("Prueba DHT22");
//Iniciamos la comunicacion Monitor Serial y editamos un texto descrip
tivo

  dht.begin();
//Iniciamos el sensor
  }

void loop(){
 delay(2000);
//Establecemos un retraso porque el DHT22 solo realiza una lectura ca
da 2 segundos

  float h = dht.readHumidity();
  float t = dht.readTemperature();
//Establecemos dos variables, una para la temperatura en ºC y otra pa
ra la humedad relativa en %

  if (isnan(h) || isnan(t)) {
    Serial.println("Error al Leer Sensor DHT¡");
    return;
//Con la funcion isnan controlamos que el valor recibido del sensor se
a un número, sino dara error
  }
  
  Serial.print("Humedad: "); 
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperatura: "); 
  Serial.print(t);
  Serial.println(" *C ");
//Mostramos la información obtenida (temperatura y humedad) en el Mo
nitor Serial
//El \t es equivalente al tabulador (separa los datos)
//El Serial.prinln nos cambia de linea en la siguiente lectura recibida

  lcd.begin(16, 2); 
//Indicamos el LCD que usamos: 16 caracteres y 2 lineas
  lcd.setCursor(0,0); 
//Situamos el cursor en la posicion 0 de la primera linea
  lcd.write("Temperatura: "); 
  lcd.setCursor(12,0); 
  lcd.print(t);
  lcd.setCursor(14,0); 
  lcd.write((char)223);
//Editamos el simbolo de los grados º
  lcd.setCursor(15,0); 
  lcd.write("C");
  lcd.setCursor(0,1); 
  lcd.write("Humedad: "); 
  lcd.setCursor(9,1); 
  lcd.print(h);
  lcd.setCursor(14,1);
  lcd.write("%");

} 

Una cosa interesante, la librería instalada permite manejar dos variables

adicionales que no hemos usado, por un lado la temperatura en grados
Farenheit y por otro el Heat Index, que es un valor que pretende relacionar
la temperatura y la humedad para dar la temperatura percibida, una especie
de "sensación térmica", expresada en grados Farenheit. Se definirían de
esta forma:

  float f = dht.readTemperature(true);
  float hi = dht.computeHeatIndex(f, h);
 3

OBJETIVOS

 Unir un sensor de temperatura y un ventilador.

 Calculando la temperatura con float.
 Usando el ventilador para disminuir la temperatura.
 Ilustrar la idea de un buffer circular

MATERIAL REQUERIDO

Arduino Uno o similar. Esta sesión acepta cualquier otro

modelo.

Una Protoboard más cables.

Un diodo LED y una resistencia de 330Ω.

Un transistor 2N2222. Comprobad que lleva rotulada esta

referencia, porque el sensor de temperatura es similar.
  Un ventilador de 5V o un motor de corriente continua.

Un Sensor de temperatura LM35DZ o similar.Comprobad que

lleva rotulada esta referencia, porque es fácil confundirlo con
un transistor.

UN CIRCUITO CON SENSOR Y ACTUADOR

Hemos ido viendo hasta ahora como utilizar un sensor de temperatura y también como usar
un pequeño transistor para mover un motor de CC, pero no los habíamos mezclado.

En esta sesión haremos un pequeño ejemplo de control, usando un sensor LM35DZ para

determinar la temperatura y un ventilador de 5V, para que cuando la primera alcance un valor
crítico, usemos el segundo a fin refrigerar el circuito.

Como no disponemos de ningún sistema a refrigerar, nos conformaremos con enfriar el propio
sensor, lo que no resulta especialmente provechoso, pero sin duda, nos servirá para
mostraros un ejemplo de control y reacción, en el mejor espíritu de un sistema automático, tal
como un regulador de temperatura con nuestros Duinos.

Veremos que la regulación de un sistema tan sencillo no tiene grandes problemas y por eso
esta sesión esta mas pensada como un ejercicio de control sencillo y que como una
regulación en toda regla.

Además el parámetro que buscamos controlar, la temperatura, tiene la virtud de variar con
lentitud, lo que nos deja mucho tiempo para reaccionar y no tener que preocuparnos por
cuestión de reaccionar con precisión en tiempo real.

ESQUEMA ELECTRONICO DEL CIRCUITO

Vamos a montar un pequeño circuito que lea la temperatura de un sensor, imprima el valor en
la consola y encienda un diodo cuando esta sobrepase un cierto umbral.
Para conectar el sensor de temperatura LM35DZ y el transistor 2N2222, os incluyo el detalle
de sus pines aquí

Aquí tenemos el esquema electrónico del circuito:

Y el circuito para protoboard sería muy sencillo también:
 PROBANDO EL SENSOR DE
TEMPERATURA

Ya hemos visto en sesiones previas como usar un sensor LM35DZ, pero si alguno queréis
revisarlo podéis hacerlo aquí: Sensor de temperatura.
Vamos a empezar probando el sensor para comprobar que funciona correctamente, y para
ello vamos a usar este programa:

const int Sensor = 0 ;             // Pin que lee la temperatura

void setup()

{    Serial.begin(115200);     }

void loop()

{    int lectura = analogRead(Sensor);

float voltaje = 5.0 /1024 * lectura ;

float temp = voltaje * 100  ;

Serial.println(temp) ;

delay(200);

samos la puerta Analog0 que definimos como una constante sensor, y en el loop leemos la
puerta y convertimos el valor de la lectura a grados centígrados (Recordad que la razón de
hacerlo así la vimos en la sesión de los sensores de temperatura) e imprimimos sin más el
valor de la temperatura. Deberías ver algo parecido a esto:

:
El sensor LM35DZ tiene un margen de error de alrededor de ± 0,5 grados y por eso las
lecturas tienen oscilación, dando diferencias de hasta un grado.

PARA LOS QUE VAN A POR NOTA

El baile de las lecturas se debe a que el mundo real nunca es perfecto y hay cosas que van
desde la incertidumbre de la medida causada por el propio sensor hasta los errores en los
convertidores de nuestro Arduino (Que no son los mejores del mundo) e incluso interferencias
electromagnéticas espurias.
Todo ello se confabula para que tengamos ese molesto baile de cifras en la medida y aunque
en este caso no tiene importancia puede convenirnos filtrar este tipo de errores y para ello
podemos promediar las n ultimas lecturas y presentar esto como el valor de la temperatura.

Para ello podemos guardarlas  digamos 8 últimas lecturas y promediarlas, con lo que
aplanaremos fuertemente los errores, y la manera más sencilla es usar un buffer circular (O
Ring Buffer)
La forma de apuntar a la posición a escribir es una variable llamada Índex que empieza en 0 y
cada vez que escribe en la posición correspondiente se incrementa en 1 ¿Y cómo evitamos
que pase del valor máximo aceptable? Pues tomando el resto del valor de Índex con respecto
al número de posiciones del array.

Buffer[ index] = temp ;

index = ++index % 8  ;

Una vez que apuntamos correctamente a la posición a escribir y después de los N valores
iniciales en los que la temperatura promedio será falsa (Porque aún no hemos leído N valores)
tendremos en Buffer las ultimas N lecturas y el resto es aritmética:
int index = 0 ;        // Posicion a escribir

const int N = 16 ;     // Numero de muestras a considerar

float Buffer[N] ;      // Array donde guardamos las lecturas

Buffer[ index] = temp ;

index = ++index  % N  ;

float Tmedia = 0 ;

for (int i=0 ; I < N ; i++)

Tmedia = Tmedia + Buffer[i] ;

Serial.println( Tmedia / N) ;
Aquí os dejo el programa complete, por si quieres jugar con el: Prog_130_2. Para N = 32
podéis ver algo así:

Podéis ver que la temperatura baila mucho menos y el baile desciende a medida que
aumentáis el número de muestras que promediáis, pero cuidado, cuanto más crece N también
crece el tiempo que tardáis en responder a los cambios ( Para N = 32 a 5 muestras por
segundo hay más de 6 segundos de tiempo de reacción).

INCLUYENDO EL VENTILADOR

Ya tenemos montado el sensor de temperatura y ahora vamos a programar el control de

arranque y apagado del motor / Ventilador, definiendo un valor umbral a partir del cual
queremos ventilar el sensor. Veamos un posible programa: Prog_130_1

int Sensor = 0 ;             // Pin que lee la temperatura

int umbral = 30 ;            // Temparatura que arranca el ventilador

const int control = 9 ;      // Gobierna el ventilador

void setup()

{   Serial.begin(115200);

pinMode(control,  OUTPUT) ;
 }

void loop()

{   int lectura = analogRead(Sensor);

float voltaje = 5.0 /1024 * lectura ;    

float temp = voltaje * 100 -5 ;

Serial.println(temp) ;

if (temp >= umbral)

digitalWrite(control, HIGH);

else

digitalWrite(control, LOW);

delay(200);

La única novedad es que comprobamos que la temperatura medida es inferior al umbral

prefijado y si no es así, arrancamos el ventilador para refrescar el sensor.