Cómo medir la temperatura y humedad con un Arduino

134108

La mayoría de nosotros confiamos en las aplicaciones del tiempo para verificar la temperatura y la humedad. Sin embargo, existe una diferencia entre cómo se siente en interiores y exteriores ¿Y qué mejor forma de medir la temperatura que creando tu propio termómetro con Arduino? Así que hoy aprenderás cómo medir la temperatura y la humedad con un arduino.

Componenetes

Placa Arduino
Una pantalla LED 4 digit 7 segment
Un sensor de temperatura y humedad DHT11
Cuatro resistencias de 1K ohmio

Antes de comenzar tenemos que conocer cómo funcionan los componentes que vamos a utilizar.

Necesitamos algo donde mostrar nuestro resultado y para ello utilizaremos una pantalla LED 4 digit 7 segment. Como su nombre lo indica está compuesta de 4 dígitos y cada dígito está compuesto de 7 LEDs más un decimal. Además, contiene 12 pines que permiten prender y apagar los LEDs, 8 de los pines son para los LEDs de cada una de las pantallas de 7 segmentos, que van desde la A a la G y el octavo es DP que se refiere al punto decimal. Los 4 pines restantes representan cada uno de los 4 dígitos de D1 a D4.

Existen dos presentaciones del sensor de temperatura y humedad DHT11, una forma individual donde solo tenemos el sensor y otra donde está insertado en una PCB. Las diferencias entre estos dos es que la versión con PCB contiene una resistencia de 5kΩ y un LED, por otra parte la versión sin PCB tiene 4 pines:

VCC: alimentación
I/O: transmisión de datos
N/C: no conectar, pin al aire
GND: tierra

Y el DHT11 con PCB tiene 3 pines:

GND: tierra
DATA: transmisión de datos
VCC: alimentación

Conexiones

Ahora que conocemos los componentes que vamos utilizar procedemos a conectarlos con nuestra placa arduino. Para ello conectamos los 8 pines de los segmentos de la pantalla LED a los pines del 2 al 9 del Arduino, respectivamente. Y los 4 dígitos los conectamos a una resistencia de 1K ohmio y luego a los pines del 13 al 10 del Arduino.

En el caso del sensor conectamos la tierra al pin GND del Arduino, el pin VCC a 5v y el pin de datos a A0.

Programemos

Importamos las librerías necesarias para utilizar el sensor y creamos las variables y constantes que necesitaremos más adelante. Le asignamos a los pines del Arduino los nombres de los pines de la pantalla para que sean más fácil de identificarlos.

// Incluimos librerías#include#include#include// Definimos el pin donde se conecta el sensor#define DHTPIN A0// Indicamos el tipo de sensor#define DHTTYPE DHT11// Inicializamos el sensor DHT11
DHT dht(DHTPIN, DHTTYPE);// Los pins de la pantalla se asignan a 2-13 respectivamente
constint pinA = 2;
constint pinB = 3;
constint pinC = 4;
constint pinD = 5;
constint pinE = 6;
constint pinF = 7;
constint pinG = 8;
constint pinP = 9;
constint D1 = 10;
constint D2 = 11;
constint D3 = 12;
constint D4 = 13;// Definimos las variablesint ten, unity, decimal;
float humidity, temp, HeatIndex;

Creamos la función setup donde iniciaremos la comunicación, el sensor y los pines de la pantalla.

voidsetup() {
  // Inicializamos comunicación serie y el sensor DHTSerial.begin(9600);
  dht.begin();

  // Inicializamos los pins como OUTPUTpinMode(pinA, OUTPUT);
  pinMode(pinB, OUTPUT);
  pinMode(pinC, OUTPUT);
  pinMode(pinD, OUTPUT);
  pinMode(pinE, OUTPUT);
  pinMode(pinF, OUTPUT);
  pinMode(pinG, OUTPUT);
  pinMode(pinP, OUTPUT);
  pinMode(D1, OUTPUT);
  pinMode(D2, OUTPUT);
  pinMode(D3, OUTPUT);
  pinMode(D4, OUTPUT);
}

Creamos un loop donde leeremos los datos del sensor utilizando la librería dht

void loop() {
  // Leemos la humedad relativa
  humidity = dht.readHumidity();// Leemos la temperatura en grados centígrados
  temp = dht.readTemperature();// Comprobamos si ha habido algún error en la lecturaif (isnan(humidity) || isnan(temp)) {
    Serial.println("Error obtenido los datos del sensor DHT11");return;
  }

  // Calculamos la sensación térmica
  HeatIndex = dht.computeHeatIndex(temp, humidity, false);
}

Para facilitar la impresión de los datos en la consola crearemos una función CalcTemp que se encargará de imprimir los datos obtenidos por el sensor y la llamaremos cada 5 segundos al final del setup

// Mostramos los valores en la consolavoid CalcTemp() {
  Serial.print("Humedad: ");
  Serial.print(humidity);
  Serial.print("%\t");
  Serial.print("Temperatura: ");
  Serial.print(temp);
  Serial.print(" *C\t");
  Serial.print("Índice de calor: ");
  Serial.print(HeatIndex);
  Serial.println(" *C");
}

// Agregamos las siguientes líneas al final del setup// Dispara la funcion CalcTemp cada 5 segundo
Timer1.initialize(5000000);
Timer1.attachInterrupt(CalcTemp);

Ya tenemos nuestra aplicación funcionando, y nos muestra la temperatura, humedad y sensación térmica a través de la consola pero nosotros queremos llevarla un paso más allá y para ello mostraremos los datos recogidos por el sensor en la pantalla.

Debemos saber que la pantalla LED 4 digit 7 segment solo permite mantener encendido un dígito a la vez, así que nos pondremos el sombrero de magos y crearemos una ilusión donde podremos ver todos los dígitos que necesitemos encendidos. Para ello tenemos que encender y apagar cada dígito en el loop.

Pero antes de hacer magia vamos a crear las funciones que mostraran cada número del 0 al 9. Además, necesitamos una función que muestre la letra C para indicar que son grados celsius y otra que limpie la pantalla

// Limpiamos la pantallavoid clearLEDs() {
  digitalWrite(D1, LOW);
  digitalWrite(D2, LOW);
  digitalWrite(D3, LOW);
  digitalWrite(D4, LOW);

  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinP, HIGH);
}
// Dibujando 0 en la pantallavoid zero() {
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, HIGH);
}
// Dibujando 1 en la pantallavoid one() {
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, HIGH);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, HIGH);
  digitalWrite(pinG, HIGH);
}
// Dibujando 2 en la pantallavoid two() {
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, HIGH);
  digitalWrite(pinG, LOW);
}
// Dibujando 3 en la pantallavoid three() {
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, HIGH);
  digitalWrite(pinG, LOW);
}
// Dibujando 4 en la pantallavoid four() {
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, HIGH);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
}
// Dibujando 5 en la pantallavoid five() {
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
}
// Dibujando 6 en la pantallavoid six() {
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
}
// Dibujando 7 en la pantallavoid seven() {
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, HIGH);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, HIGH);
  digitalWrite(pinG, HIGH);
}
// Dibujando 8 en la pantallavoid eight() {
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
}
// Dibujando 9 en la pantallavoid nine() {
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
}
// Dibujamos C en la pantallavoid celsius() {
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, HIGH);
}

Para facilitarnos las cosas, vamos a crear dos funciones una para elegir cual dígito vamos a encender y otra para elegir qué número va a mostrar.

// Iluminamos el dígito correspondiente
void pickDigit(int DigitNumber) {
  switch(DigitNumber) {
    case1:
      digitalWrite(D1, HIGH);break;
    case2:
      digitalWrite(D2, HIGH);break;
    case3:
      digitalWrite(D3, HIGH);break;default:
      digitalWrite(D4, HIGH);break;
  }
}
// Indicamos que número mostrar en la pantalla
void pickNumber(int Number) {
  // Number es un número entero entre 0 y 9.switch(Number) {
    default:
      zero();break;
    case1:
      one();break;
    case2:
      two();break;
    case3:
      three();break;
    case4:
      four();break;
    case5:
      five();break;
    case6:
      six();break;
    case7:
      seven();break;
    case8:
      eight();break;
    case9:
      nine();break;
  }
}

Para mostrar cada dígito individualmente en la pantalla necesitamos separar el resultado de la temperatura en unidad, decena y decimal utilizando unas ecuaciones que las ejecutaremos dentro del loop

// Descomponemos la temperatura en unidades
ten = temp/10;
unity = temp-(ten*10);
decimal = (temp-ten*10-unity)*10;

Ahora sí, es hora de hacer magia. Dentro del loop después de separar la unidad, decena y decimal limpiamos la pantalla, escogemos cual dígito es el que se va a encender, le indicamos el número y cuánto tiempo durará encendido, así con el dígito 1 y 3, en el segundo dígito haremos que se encienda el punto decimal. Y el cuarto dígito mostrará la letra C así que llamaremos a la función celsius en vez de pickNumber.

// Dibujar temperatura en pantalla
clearLEDs();
pickDigit(1);
pickNumber(ten);
delay(5);

clearLEDs();
pickDigit(2);
pickNumber(unity);
digitalWrite(pinP, LOW);
delay(5);

clearLEDs();
pickDigit(3);
pickNumber(decimal);
delay(5);

clearLEDs();
pickDigit(4);
celsius();
delay(5);

Ya que el loop es tan rápido y la pantalla se enciende y apaga a una velocidad que el ojo no puede ver se crea una ilusión en la que parece que todos están encendidos al mismo tiempo.

Hasta ahora solo estamos mostrando la temperatura pero también tenemos los datos de humedad. Es tu turno de ponerte manos a la obra, imprime los valores de la temperatura y humedad a través de la pantalla LED y comparte tu solución en los comentarios. Aquí puedes encontrar el código completo por si lo necesitas.

Si quieres crear esta y muchas otras cosas con Arduino te invito a completar el curso de Fundamentos de Desarrollo de Hardware con Arduino.

hace 4 años

Escribe tu comentario

+ 2

Entradas relacionadas

Controlar motores usando un transistor

!Hola amigos¡ Como ya vieron, en este curso que imparte nuestro profesor Ricardo Celis hemos aprendido a controlar un motor dc y a variar su

Angrub

¿Cómo escoger un arduino?

Muchas preguntas que he leído en este curso es sobre cual es la forma correcta de escoger un Arduino. Para empezar debemos de recordar que c

barevalo

¿Cómo se genera la energía eléctrica?

Si bien el curso se trata principalmente de electrónica, creo que es importante conocer un poco de las bases y los principios fundamentales

everitosan

Fritzing software libre multiplaforma para realizar tus prototipos electrónicos

Buen día. Muchas veces cuando estamos estudiando ya sea de manera auto didácta o académica necesitamos software para llevar a cabo procesos

davidlatorre