Trabajando con el sensor de temperatura

DHT11-Temperature

Objetivos

  • Calcular la temperatura con un tipo float.
  • Construir una alarma de temperatura.
  • Presentar los sensores DHT11.
  • Mostrar como leerlos utilizando la librería de control.
  • Escribir un programa básico de uso.

Material requerido

ArduinoUNO-300x300
  • Arduino Uno o similar. Esta sesión acepta cualquier otro modelo de Arduino.
Img_3_4
  •  Una Protoboard.
RedLed_
  • Un diodo LED.
Img_3_5
  • Una resistencia de 330 Ohmios.
Img_3_6-300x185
  • Algunos cables de Protoboard.
tmp36DHT11-Temperature
  • Un Sensor de temperatura TMP36, o  LM35DZ.
    Comprobad que lleva rotulada esta referencia, porque es fácil confundirlo con un transistor.
  • También podemos utilizar un módulo sensor de temperatura y humedad relativa: el DHT11

Sensor de temperatura.

Un sensor de temperatura es simplemente un chip que nos devuelve un valor de tensión proporcional a la temperatura a la que está sometido. En este punto vamos a utilizar unos modelos comerciales muy extendidos y fáciles de encontrar por muy poco dinero: TMP36 o LM35DZ y el DTH11.

Vamos a ver como los usamos. Lo primero, tenéis que buscar la hoja de especificaciones del fabricante. (Busca TMP36 o  LM35DZ data sheet). Aunque al principio no es fácil acostumbrarse a leer este tipo de documentación, en último término es a donde hay que ir cuando queráis saber exactamente las características de su funcionamiento.

Pero el resumen podría ser  más o menos así:

temperature_tmp36pinout lm35dz
  • Mide la temperatura en grados centígrados.
  • Funciona entre -50º C y 125ºC para el TMP36.
  • Funciona entre 0º C y 100ºC para el LM35DZ .
  • No es especialmente preciso, ya que tiene ± 1ºC de incertidumbre, pero normalmente nos sobra para proyectos sencillos y es muy barato.
  • EL encapsulado es similar al de un transistor y también tiene tres patas, así que mucho cuidado con confundirlos. Intentad leer las letras que lleva serigrafiadas (si podéis, porque suelen ser tan pequeñas que a veces no se leen ni con lupa).
  • El pin central es el de señal, pero para saber cuál es GND y 5V, el encapsulado tiene una cara plana y otra curva. Poniendo la cara plana mirando hacia vosotros con las patas hacia abajo(de modo que podais leer el  modelo),  el pin de la izquierda es alimentación 5V y naturalmente el otro es GND.

SI conectáis la tensión al revés, tendréis tiempo de reaccionar y cambiarla, pero mucho cuidado porque se calentará como para haceros una quemadura dolorosa.

Si veis que está caliente no tratéis de sacarlo con los dedos, simplemente desconectad el Arduino y dadle un rato para que se enfríe.

Y el DHT11

dth11_pinout

La familia DHT nos proporcionan de forma digital la temperatura y la humedad, con diferente precisión según el modelo.

Básicamente hay dos variantes DHT11 y DHT22

Las características del DHT11 son:

  • Muy barato, sobre 2€
  • Funciona con 3,3 y 5V de alimentación
  • Rango de temperatura: de 0º a 50º con 5% de precisión (pero solo mide por grados, no fracciones)
  • Rango de humedad: de 20% al 80% con 5% de precisión
  • 1 muestra por segundo.
  • Bajo consumo
  • Devuelve la medida en ºC

En cuanto al DHT22:

  • Barato, entre 4 y 5 €
  • Funciona con 3,3 y 5V de alimentación
  • Rango de temperatura: de -40º a 125º ±0.5°C
  • Rango de humedad: de 0% al 100% con 5% de precisión.
  • Lee 2 veces por segundo.
  • Bajo consumo.
  • Devuelve la medida en ºC

En cuanto a la forma de conectarlos y programarlos es la misma para ambos modelos y veremos que hay desarrolladas librerías para Arduino que soportan los dos de una forma sencilla.

Destacar que el chip incorpora electrónica para hacer internamente la conversión de temperatura y humedad y nos da un valor de medida de forma digital, es decir, que no necesitamos un pin analógico como en el caso del TMP36, sino que lo leeremos con un pin digital.

El circuito para TMP36

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. Aquí tenemos el esquema electrónico:

Sesion_15_esquema

Y el circuito para protoboard sería muy sencillo también:

Sesion_15_2

Calculando la temperatura.

El fabricante del TMP36 y del LM35DZ nos dice que la salida de tensión será de 10 mV (mili voltios) por cada grado de temperatura y además sabemos que nuestro Arduino mide en las puertas analógicas una máximo de 1.024 para 5V (y 0 para 0V), por tanto, para una lectura dada, el valor en voltios de la medida será:

Img_15_5
Y como cada voltio equivale a 100ºC ( 1V / 10mv = 100), la temperatura en grados Celsius es resultado de multiplicar esto por 100.

Pero para que la cosa no sea tan fácil el fabricante del TMP36 nos dice que el 0V no es 0º sino -50º (y así poder leer valores bajo cero), así que al total hay que restarle 50. En cambio como el LM35DZ empieza en 0º, no hay que restarle nada, es más cómodo de manejar.

Resumiendo. Para calcular la temperatura en ºC a partir de la lectura de Arduino:

Img_15_6-300x79Es conviene utilizar una variable de tipo float en cuanto haya una división de por medio.

Cada vez que tomemos una muestra de nuestra entrada analógica vamos a calcular la temperatura y si sobrepasa el umbral definido, damos orden de activar la alarma, en caso contrario la apagamos.

Como la temperatura es algo que varía lentamente usaremos un delay para que solo nos dé una medida por segundo.

El programa de control.

En primer lugar vamos a definir un par de variables:

int sensor  = 0 ;
int umbral = 25 ;

sensor es el pin analógico (A0) al que conectamos el sensor de temperatura y umbral el valor a partir del cual disparamos la alarma de temperatura.

Y pasando los cálculos de la página anterior a C++ nos quedaría algo parecido a:

void loop ()
        {
            int lectura = analogRead(sensor);
            float voltaje = 5.0 /1024 * lectura ; // Atencion aquí
            // Si es un LM35DZ la formula será temp = voltaje * 100 ;
            float temp = voltaje * 100 -50 ;
            Serial.println(temp) ;

}

Importante: En la línea donde calculamos el voltaje hemos escrito 5.0 y no 5.  Esto es para evitar que C++ intente hacer una división entre enteros y nos desprecie los decimales.

Haced la prueba de escribir en vuestro programa el 5 a secas y veréis que el resultado de temperatura será siempre -50 ¿Porque? Pues sencillamente porque la parte entera de 5/1024 es 0. Así que por mucho que después multipliquemos por lectura seguirá siendo 0. Y nuestro programa dice que para 0V la temperatura es -50ºC.

Ya solo nos resta comprobar si la temperatura alcanza el umbral y encender el LED o apagarlo.

int sensor = 0 ;
int umbral = 25 ; // por ejemplo

     void setup()
        {
            Serial.begin(9600);
            pinMode(11,OUTPUT);
        }
     void loop()
       {
            int lectura = analogRead(sensor);
            float voltaje = 5.0 /1024 * lectura ; // Atencion aquí
            // float temp = voltaje * 100 ; para el LM35DZ
            float temp = voltaje * 100 -50 ;

            Serial.println(temp) ;
            if (temp >= umbral)
                digitalWrite(11, HIGH) ;
            else

                 digitalWrite(11,LOW);
             delay(1000);

}

Si disponéis de un pequeño ventilador de 5V, de los que suelen tener en las tiendas de informática (o si desmontáis un equipo viejo), sería fácil cambiar el LED por ese ventilador  y orientarlo hacia el sensor.

El circuito para DHT11

La conexión es trivial, pero cabe destacar que se vende en dos encapsulados, uno de tres pines que son GND, Data y Vcc, y otro 4 pines y uno de ellos, sencillamente sobra y no se conecta. Normalmente viene rotulado en el sensor el nombre de cada pin, y si no ya sabeis, a buscar el manual en Google.

Vamos con el esquema por cortesía de Fritzing:

2

Y aquí tenemos el esquema de protoboard.

temperature-humidity-arduino-chiosz1

El programa de control

En primer lugar, tenemos que descargar una librería para manejarlos cómodamente, DX11.zip e importarla. Aquí tenéis la librería  DHT11.

Para importarla :

1

Par incluir la la librería DHT11 en nuestra aplicación:

#include <DHT11.h>

Y definimos una instancia del sensor donde declaramos el pin al que esta conectado.

int pin=2;
DHT11 dht11(pin);

Leerlo ahora es muy sencillo:

int error ;
float temp, humi;
error  =  dht11.read(humi, temp)

Basta con hacer dht11.read() pasándole las variables donde queremos el resultado, y comprobamos que no haya errores (Siempre es buena idea comprobar que no hay error cuando hacemos una llamada). El programa completo seria más o menos algo así:

#include <DHT11.h>

int pin=2;
DHT11 dht11(pin);

void setup()
   {
       Serial.begin(9600);
   }

void loop()
   {
       int err;
       float temp, hum;

      // Si devuelve 0 es que ha leído bien
       if((err = dht11.read(hum, temp)) == 0)   
          {
             Serial.print(“Temperatura: “);
             Serial.print(temp);
             Serial.print(” Humedad: “);
             Serial.print(hum);
             Serial.println();
          }
       else
          {
             Serial.println();
             Serial.print(“Error Num :”);
             Serial.print(err);
             Serial.println();
          }
       delay(1000);    
   }

El resultado se envía a la consola y aquí podéis ver una muestra.

Img_23_1