En esta sección podrás conocer un poco los sensores de temperatura y humedad, nos referimos al dht22 y al ds18b20, son de los más utilizados en el mundo de los microcontroladores, la gran ventaja de ambos sensores es que trabajan con señales digitales, por lo que abren el abanico de posibilidades de conexión ya que todos los microcontroladores disponen de entradas digitales, además están calibrados de fábrica, lo que facilita su uso.
Además podrás ver algunos ejemplos de uso de estos sensores con Arduino, descargar los datasheet de ambos sensores, las librerías para su uso con el Ide de Arduino y realizar gráficas con los datos de ambos sensores.
Un sensor digital es un dispositivo, que puede adoptar únicamente dos valores de salida en binario 1 o 0 (encendido o apagado, sí o no....) los estados de un sensor digital son únicos, por tanto lo único que podremos extraer de estos son señales digitales (activado o desactivado).
En informática, la unidad mínima es es el bit, esto es porque al ser un sistema binario o digital en un bit solo podremos almacenar un uno o un cero, aunque los pc realmente no manejan bits, sino bytes, un byte es una agrupación de ocho bits, por tanto con un byte tendremos en binario del 00000000 al 11111111, que da una combinación de 256 posibilidades diferentes. En decimal podríamos escribir desde 0 hasta 255.
El DHT22, o AM2302 es un sensor digital de temperatura y humedad calibrado en fábrica, consta de un microprocesador que utiliza un sensor capacitivo de humedad, para medir la humedad relativa del aire, cuanto más se aproxima el valor al 100% más húmedo está el ambiente medido, también incluye un termistor para medir el aire circundante, y calcular la temperatura de este, muestra los datos mediante una señal digital en el pin de datos. Se puede obtener nuevos datos una vez cada 2 segundos.
Lo bueno de estos dispositivos, es por una parte su bajo coste y por otra el poder sensar dos parámetros analógicos como son la temperatura y la humedad de forma digital, pues el sensor hace las conversiones.
El pin uno (el de la izquierda) es la alimentación 3 - 6V del sensor, el segundo pin es la salida de datos, el tercer pin no se usa, y el cuarto (último) pin es la tierra.
Hay librerías de uso disponibles para Arduino y Raspberry pi.
En mi experiencia personal con este sensor, a la hora de conectarlo a la Raspberry Pi, es necesario una resistencia de pullup (conectada entre el pin de salida de datos y 3.3v, la tensión de alimentación del sensor en Raspberry Pi).
Para el uso con Arduino no he necesitado nada adicional, simplemente configuramos el pin de Arduino como entrada y activamos el pullup interno.
Si quieres ver los esquemas y como usarlo en Esp8266, pásate por aquí.
Aquí les dejo la librería que uso para Arduino, desarrollada por Ben Adams en 2011.
Descargar librería Dht22 de ArduinoAquí les dejo un ejemplo de lectura de un Dht22 o Am2320, con arduino, lo único que tenemos que hacer, es conectar los 3 pines del sensor directos al Arduino (GND del sensor con GND del arduino, VCC a 5V de arduino y Data del sensor al pin digital de Arduino que queramos), y programarlo con este ejemplo.
*Nota el uso de delay para completamente el microprocesador, impidiendo que este realice otras funciones, por tanto no debemos usar el delay en ningún programa en ejecución solo para pruebas de funcionamiento.
//incluimos libreria del Dht22
// include DHT22 library
#include <DHT22.h>
// Only used for sprintf
// uso de studio solo para impresion
#include <stdio.h>
// Data wire is plugged into port 7 on the Arduino
// Salida data del Dht22 conectada al pin 7 de Arduino
#define DHT22_PIN 7
// Setup a DHT22 instance
//Configura una instancia de la librería DTH22
DHT22 myDHT22(DHT22_PIN);
void setup(void)
{
// pin 7 input
//Declara pin 7 como entrada
pinMode(7,INPUT);
//activa el pullup en pin 7
// pin 7 pullup
digitalWrite(7,HIGH);
// start serial port
//inicia puerto serie a 9600
Serial.begin(9600);
//imprime en puerto serie
// print serial port
Serial.println("DHT22 Library Demo");
}
void loop(void)
{
DHT22_ERROR_t errorCode;
// El sensor solo puede ser leido cada 1-2
// segundos despues de ser alimentado
//lo dejaremos en dos para no obtener errores
// The sensor can only be read from every 1-2s, and requires a minimum
// 2s warm-up after power-on.
delay(2000);
Serial.print("Requesting data...");
//pedimos los datos al sensor
// We ask the sensor data
errorCode = myDHT22.readData();
// hacemos un switch case con el resultado
// solo obtendremos datos si no hay error en caso contrario mostrara el error
// only obtain data if no error otherwise show the error
switch(errorCode)
{
case DHT_ERROR_NONE:
Serial.print("Got Data ");
Serial.print(myDHT22.getTemperatureC());
Serial.print("C ");
Serial.print(myDHT22.getHumidity());
Serial.println("%");
// Alternately, with integer formatting which is clumsier but more compact to store and
// can be compared reliably for equality:
//
char buf[128];
sprintf(buf, "Integer-only reading: Temperature %hi.%01hi C, Humidity %i.%01i %% RH",
myDHT22.getTemperatureCInt()/10, abs(myDHT22.getTemperatureCInt()%10),
myDHT22.getHumidityInt()/10, myDHT22.getHumidityInt()%10);
Serial.println(buf);
break;
case DHT_ERROR_CHECKSUM:
Serial.print("check sum error ");
Serial.print(myDHT22.getTemperatureC());
Serial.print("C ");
Serial.print(myDHT22.getHumidity());
Serial.println("%");
break;
case DHT_BUS_HUNG:
Serial.println("BUS Hung ");
break;
case DHT_ERROR_NOT_PRESENT:
Serial.println("Not Present ");
break;
case DHT_ERROR_ACK_TOO_LONG:
Serial.println("ACK time out ");
break;
case DHT_ERROR_SYNC_TIMEOUT:
Serial.println("Sync Timeout ");
break;
case DHT_ERROR_DATA_TIMEOUT:
Serial.println("Data Timeout ");
break;
case DHT_ERROR_TOOQUICK:
Serial.println("Polled to quick ");
break;
}
}
El DS18B20 es un sensor digital de temperatura de la casa Dallas Semi Conductors, el rango de temperatura es de -55 a 125 ℃, la precisión de la temperatura es de ±0.5 ℃, su característica más destacable es el poder usar varios sensores de este tipo leídos con un solo pin digital. Tiene comunicación serial de 9-12 Bits configurable por software.
El pin uno (el de la izquierda) es la tierra o (GND), el segundo pin es la salida de datos , el tercer pin es la alimentación de 3V a 5V según las condiciones de uso del sensor.
Dejo la imagen anterior para que no haya dudas con respecto al orden de pines, pues en el esquema de fritzing el ds18b20 sale al revés.
Hay librerías de uso disponibles para Arduino y Raspberry pi.
Descargar librería Onewire de Ds18b20 para ArduinoAquí les dejo un ejemplo de lectura de ds18b20, necesitareis la librería Onewire que podéis descargar un poco más arriba, un arduino una resistencia de 4,7k y un sensor ds18b20.
Lo interesante de este ejemplo, es que nos hará de scanner para buscar todos los dispositivos ds18b20 que haya conectados y nos dirá su número único identificativo.
*Nota el uso de delay para completamente el microprocesador, impidiendo que este realice otras funciones, por tanto no debemos usar el delay en ningún programa en ejecución solo para pruebas de funcionamiento.
//incluimos libreria para ds18b20
// include library for ds18b20
#include <OneWire.h>
// conectamos en pin 7 (es necesaria una resistencia de 4,7k)
// on pin 7 (a 4.7K resistor is necessary)
OneWire ds(7);
void setup(void) {
// start serial port
//inicia puerto serie a 9600
Serial.begin(9600);
}
void loop(void) {
// variables para datos
byte i;
byte present = 0;
byte type_s;
byte data[12];
byte addr[8];
float celsius, fahrenheit;
if ( !ds.search(addr)) {
Serial.println("No more addresses.");
Serial.println();
ds.reset_search();
delay(250);
return;
}
Serial.print("ROM =");
for( i = 0; i < 8; i++) {
Serial.write(' ');
Serial.print(addr[i], HEX);
}
if (OneWire::crc8(addr, 7) != addr[7]) {
Serial.println("CRC is not valid!");
return;
}
Serial.println();
// el primer byte de la Rom indica que tipo de chip es
// the first ROM byte indicates which chip
switch (addr[0]) {
case 0x10:
Serial.println(" Chip = DS18S20"); // or old DS1820
type_s = 1;
break;
case 0x28:
Serial.println(" Chip = DS18B20");
type_s = 0;
break;
case 0x22:
Serial.println(" Chip = DS1822");
type_s = 0;
break;
default:
Serial.println("Device is not a DS18x20 family device.");
return;
}
ds.reset();
ds.select(addr);
ds.write(0x44, 1); // start conversion, with parasite power on at the end
delay(1000); // maybe 750ms is enough, maybe not
// we might do a ds.depower() here, but the reset will take care of it.
present = ds.reset();
ds.select(addr);
ds.write(0xBE); // Read Scratchpad
Serial.print(" Data = ");
Serial.print(present, HEX);
Serial.print(" ");
for ( i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
Serial.print(data[i], HEX);
Serial.print(" ");
}
Serial.print(" CRC=");
Serial.print(OneWire::crc8(data, 8), HEX);
Serial.println();
// Convert the data to actual temperature
// because the result is a 16 bit signed integer, it should
// be stored to an "int16_t" type, which is always 16 bits
// even when compiled on a 32 bit processor.
int16_t raw = (data[1] << 8) | data[0];
if (type_s) {
raw = raw << 3; // 9 bit resolution default
if (data[7] == 0x10) {
// "count remain" gives full 12 bit resolution
raw = (raw & 0xFFF0) + 12 - data[6];
}
} else {
byte cfg = (data[4] & 0x60);
// at lower res, the low bits are undefined, so let's zero them
if (cfg == 0x00) raw = raw & ~7; // 9 bit resolution, 93.75 ms
else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
//// default is 12 bit resolution, 750 ms conversion time
}
celsius = (float)raw / 16.0;
fahrenheit = celsius * 1.8 + 32.0;
Serial.print(" Temperature = ");
Serial.print(celsius);
Serial.print(" Celsius, ");
Serial.print(fahrenheit);
Serial.println(" Fahrenheit");
}
Seleccione un sensor, elige un rango de fecha, o fecha y hora, cambia el tipo de gráfica y pulsa el botón "Solicitar gráfica" para visualizar la gráfica.