Arduino lee datos de humedad y temperatura de DHT11, DHT22, SHTC3

Discusión Técnica Sistemas embebidos
, , , ,
1

Este artículo explica cómo leer los datos de tres sensores de temperatura y humedad —DHT11, DHT22 y SHTC3— utilizando una placa NodeMcu y enviarlos por el puerto serie. Para cada sensor, proporciono ejemplos de código tanto con bibliotecas de terceros como sin ellas.

Tutorial de configuración del entorno de desarrollo ESP8266: https://blog.zeruns.com/archives/526.html

Las direcciones de compra de los sensores utilizados en este artículo se encuentran al final del artículo.

DHT11

El DHT11 es un sensor de temperatura y humedad con salida de señal digital calibrada. Su precisión es de ±5% RH para humedad y ±2°C para temperatura, con un rango de medición de 20-90% RH para humedad y 0~50°C para temperatura. Tiene una precisión limitada, pero es económico. El DHT11 utiliza comunicación de bus único. El voltaje de alimentación es de 3.3~5 V.

1016×449 84.3 KB

Usar la biblioteca DHT

Utilice la biblioteca DHT sensor library (debe instalarse manualmente; la guía de instalación se encuentra en el Tutorial de configuración del entorno de desarrollo ESP8266 mencionado anteriormente) para leer directamente los datos del DHT11.

#include 
``````c
#include <DHT.h>        // Incluir la biblioteca DHT

DHT dht(D1, DHT11);      // Configurar el pin de datos y el tipo de sensor

void setup(){ // Función de inicialización, se ejecuta solo una vez al inicio del programa
  Serial.begin(115200);   // Configurar la velocidad del puerto serie
  dht.begin();       
}

//https://blog.zeruns.com
void loop() {
  delay(1000);                  // Retraso de 1000 milisegundos
  float RH = dht.readHumidity();   // Leer los datos de humedad
  float T = dht.readTemperature(); // Leer los datos de temperatura
  Serial.print("Humidity:");  // Imprimir "Humidity:" por el puerto serie
  Serial.print(RH);           // Imprimir los datos de humedad
  Serial.print("%");
  Serial.print("  Temperature:");
  Serial.print(T);            // Imprimir los datos de temperatura
  Serial.println("C"); 
  Serial.println("https://blog.zeruns.com");
}

Sin usar biblioteca

Leer los datos directamente escribiendo el programa siguiendo el manual de datos del DHT11.

Manual del DHT11: http://go.zeruns.com/G

#define data D1   // El pin de datos (Pin 2) del DHT11 está conectado al pin D1 de la placa NodeMcu

unsigned char i;  // Variable entera sin signo de 8 bits
float RH,T;       // Número de punto flotante de precisión simple (32 bits)
byte RH_H,RH_L,T_H,T_L,sum,check;  // Variables de byte, números binarios

void setup() {    // Función de inicialización, se ejecuta solo una vez al inicio del programa
  Serial.begin(115200);   // Configurar la velocidad del puerto serie
}

void loop() {     // Función de bucle, se ejecuta repetidamente después de la inicialización
  delay(1000);    // Retraso de 1000 milisegundos
  DHT11();        // Obtener datos de temperatura y humedad
  Serial.print("Humidity:");  // Imprimir "Humidity:" por el puerto serie
  Serial.print(RH);           // Imprimir los datos de humedad
  Serial.print("%");
  Serial.print("  Temperature:");
  Serial.print(T);            // Imprimir los datos de temperatura
  Serial.println("C"); 
  Serial.println("https://blog.zeruns.com");
}

void DHT11()
{
  RH_H=0,RH_L=0,T_H=0,T_L=0,sum=0,check=0;
  pinMode(data,OUTPUT);   // Configurar el pin como salida
  digitalWrite(data,1);   // Establecer el pin en nivel alto
  delay(10);              // Retraso de 10 milisegundos
  digitalWrite(data,0);   // Establecer el pin en nivel bajo
  delay(25);              // Retraso de 25 milisegundos
  digitalWrite(data,1);   // Establecer el pin en nivel alto
  pinMode(data,INPUT);    // Configurar el pin como entrada
  delayMicroseconds(30);  // Retraso de 30 microsegundos
  if(!digitalRead(data))  // Verificar si el pin de entrada está en nivel bajo
  {//https://blog.zeruns.com
    while(!digitalRead(data));  // Esperar hasta que la entrada sea alta
    while(digitalRead(data));   // Esperar hasta que la entrada sea baja
    for(i=0;i<8;i++)            // Repetir 8 veces
    {   
      while(!digitalRead(data));// Esperar hasta que la entrada sea alta   
      delayMicroseconds(28);    // Retraso de 28 microsegundos
      if(digitalRead(data)){    // Verificar si la entrada está en nivel alto
        bitWrite(RH_H, 7-i, 1); // Escribir 1 en el bit 7-i (contando desde la derecha) de la variable RH_H  
        while(digitalRead(data));
      }
    }
    for(i=0;i<8;i++)
    {
      while(!digitalRead(data));
      delayMicroseconds(28);
      if(digitalRead(data)){
        bitWrite(RH_L, 7-i, 1);
        while(digitalRead(data));
      }
    }
    for(i=0;i<8;i++)
    {
      while(!digitalRead(data));
      delayMicroseconds(28);
      if(digitalRead(data)){  
        bitWrite(T_H, 7-i, 1);
        while(digitalRead(data));
      }
    }
    for(i=0;i<8;i++)
    {
      while(!digitalRead(data));
      delayMicroseconds(28);
      if(digitalRead(data)){  
        bitWrite(T_L, 7-i, 1);
        while(digitalRead(data));
      }
    }
    for(i=0;i<8;i++)
    {
      while(!digitalRead(data));
      delayMicroseconds(28);
      if(digitalRead(data)){  
        bitWrite(check, 7-i, 1);
        while(digitalRead(data));
      }
    }
   }
  sum=RH_H + RH_L + T_H + T_L;
  byte sum_temp=0;
  // Leer los últimos 8 bits de sum y escribirlos en sum_temp
  for(i=0;i<8;i++){
    bitWrite(sum_temp,i,bitRead(sum,i)); 
  }//https://blog.zeruns.com
  if(check==sum_temp){  // Verificar los datos
    RH=RH_H+float(RH_L)/10;
    T=T_H+float(T_L)/10;
  }
}

Resultado

725×500 21.8 KB

DHT22 (AM2302)

El DHT22 (AM2302) es un sensor de temperatura y humedad con salida digital calibrada. Su precisión es de ±2% RH en humedad y ±0.5°C en temperatura, con un rango de humedad de 0-100% RH y temperatura de -40 a 80°C, con resolución de 0.1. Tiene alta precisión y un precio asequible. El DHT22 utiliza comunicación de un solo hilo. Voltaje de alimentación: 3.3 a 5 V.

442×386 26.3 KB

Usar la biblioteca DHT

Utilizar la biblioteca DHT sensor library para leer directamente los datos del DHT22.

#include <DHT.h>        // Incluir la biblioteca DHT

DHT dht(D1, DHT22);      // Configurar el pin de datos y el tipo de sensor

void setup(){ // Función de inicialización, se ejecuta solo una vez al inicio del programa
  Serial.begin(115200);   // Configurar la velocidad del puerto serie
  dht.begin();       
}

//https://blog.zeruns.com
void loop() {
  delay(1000);                  // Retraso de 1000 milisegundos
  float RH = dht.readHumidity();   // Leer los datos de humedad
  float T = dht.readTemperature(); // Leer los datos de temperatura
  Serial.print("Humidity:");  // Imprimir "Humidity:" por el puerto serie
  Serial.print(RH);           // Imprimir los datos de humedad
  Serial.print("%");
  Serial.print("  Temperature:");
  Serial.print(T);            // Imprimir los datos de temperatura
  Serial.println("C"); 
  Serial.println("https://blog.zeruns.com");
}

Sin usar biblioteca

Leer los datos directamente escribiendo el programa siguiendo el manual de datos del DHT22.

Manual del DHT22: http://go.zeruns.com/H

#define data D1   // El pin de datos (Pin 2) del DHT22 está conectado al pin D1 de la placa NodeMcu

unsigned char i;  // Variable entera sin signo de 8 bits
float RH,T;       // Número de punto flotante de precisión simple (32 bits)
byte RH_H,RH_L,T_H,T_L,sum,check;  // Variables de byte, números binarios

void setup() {    // Función de inicialización, se ejecuta solo una vez al inicio del programa
  Serial.begin(115200);   // Configurar la velocidad del puerto serie
}

void loop() {     // Función de bucle, se ejecuta repetidamente después de la inicialización
  delay(1000);    // Retraso de 1000 milisegundos
  DHT11();        // Obtener datos de temperatura y humedad
  Serial.print("Humidity:");  // Imprimir "Humidity:" por el puerto serie
  Serial.print(RH);           // Imprimir los datos de humedad
  Serial.print("%");
  Serial.print("  Temperature:");
  Serial.print(T);            // Imprimir los datos de temperatura
  Serial.println("C"); 
  Serial.println("https://blog.zeruns.com");
}

void DHT11()
{
  RH_H=0,RH_L=0,T_H=0,T_L=0,sum=0,check=0;
  pinMode(data,OUTPUT);   // Configurar el pin como salida
  digitalWrite(data,1);   // Establecer el pin en nivel alto
  delay(10);              // Retraso de 10 milisegundos
  digitalWrite(data,0);   // Establecer el pin en nivel bajo
  delay(25);              // Retraso de 25 milisegundos
  digitalWrite(data,1);   // Establecer el pin en nivel alto
  pinMode(data,INPUT);    // Configurar el pin como entrada
  delayMicroseconds(30);  // Retraso de 30 microsegundos
  if(!digitalRead(data))  // Verificar si el pin de entrada está en nivel bajo
  {//https://blog.zeruns.com
    while(!digitalRead(data));  // Esperar hasta que la entrada sea alta
    while(digitalRead(data));   // Esperar hasta que la entrada sea baja
    for(i=0;i<8;i++)            // Repetir 8 veces
    {   
      while(!digitalRead(data));// Esperar hasta que la entrada sea alta   
      delayMicroseconds(28);    // Retraso de 28 microsegundos
      if(digitalRead(data)){    // Verificar si la entrada está en nivel alto
        bitWrite(RH_H, 7-i, 1); // Escribir 1 en el bit 7-i (contando desde la derecha) de la variable RH_H  
        while(digitalRead(data));
      }
    }
    for(i=0;i<8;i++)
    {
      while(!digitalRead(data));
      delayMicroseconds(28);
      if(digitalRead(data)){
        bitWrite(RH_L, 7-i, 1);
        while(digitalRead(data));
      }
    }
    for(i=0;i<8;i++)
    {
      while(!digitalRead(data));
      delayMicroseconds(28);
      if(digitalRead(data)){  
        bitWrite(T_H, 7-i, 1);
        while(digitalRead(data));
      }
    }
    for(i=0;i<8;i++)
    {
      while(!digitalRead(data));
      delayMicroseconds(28);
      if(digitalRead(data)){  
        bitWrite(T_L, 7-i, 1);
        while(digitalRead(data));
      }
    }
    for(i=0;i<8;i++)
    {
      while(!digitalRead(data));
      delayMicroseconds(28);
      if(digitalRead(data)){  
        bitWrite(check, 7-i, 1);
        while(digitalRead(data));
      }
    }
   }
  sum=RH_H + RH_L + T_H + T_L;
  byte sum_temp=0;
  // Leer los últimos 8 bits de sum y escribirlos en sum_temp
  for(i=0;i<8;i++){
    bitWrite(sum_temp,i,bitRead(sum,i)); 
  }//https://blog.zeruns.com
  if(check==sum_temp){
    if(bitRead(RH_H,7)==1){ // Verificar si la temperatura es negativa
      T=-(float(T_H<<8)+float(T_L))/10;
    }else{
      T=(float(T_H<<8)+float(T_L))/10;
    }
    RH=(float(RH_H<<8)+float(RH_L))/10;
  }  
}

Resultado

725×500 22.4 KB

SHTC3

El SHTC3 es un sensor de temperatura y humedad con salida digital calibrada. Su precisión es de ±2% RH en humedad y ±0.2°C en temperatura, con un rango de humedad de 0-100% RH y temperatura de -40 a 125°C, con resolución de 0.01. Tiene alta precisión y un precio relativamente bajo, pero la documentación es escasa. El SHTC3 utiliza comunicación I2C (IIC). Voltaje de alimentación: 1.62 a 3.6 V.

Manual del SHTC3: http://go.zeruns.com/I

454×348 138 KB

Usar la biblioteca Wire (I2C)

Utilizar la biblioteca Wire para comunicarse con el SHTC3 y leer los datos.

/* https://blog.zeruns.com
 * Conexión
 * SHTC3    Placa de desarrollo
 * SCL      SCL (en la placa NodeMcu es D1)
 * SDA      SDA (en la placa NodeMcu es D2)
 */
#include <Wire.h>

#define SHTC3_ADDRESS 0x70  // Definir la dirección I2C del dispositivo SHTC3 como 0x70
float T, RH;

void setup() {    // Función de inicialización, se ejecuta solo una vez al inicio del programa
  Serial.begin(115200);   // Configurar la velocidad del puerto serie
  Wire.begin();   // Inicializar como maestro I2C
}

void loop() {     // Función de bucle, se ejecuta continuamente después de la inicialización
  delay(1000);    // Retraso de 1000 milisegundos
  SHTC3();        // Obtener datos de temperatura y humedad
  Serial.print("Humedad:");  // Imprimir "Humedad:" por el puerto serie
  Serial.print(RH);           // Imprimir datos de humedad por el puerto serie
  Serial.print("%");
  Serial.print("  Temperatura:");
  Serial.print(T);            // Imprimir datos de temperatura por el puerto serie
  Serial.println("C"); 
  Serial.println("https://blog.zeruns.com");
}

void SHTC3(){   // Obtener datos de temperatura y humedad
  Wire.beginTransmission(SHTC3_ADDRESS); // Iniciar transmisión al dispositivo I2C con dirección 0x70.
  Wire.write(byte(0xE0));       // Enviar instrucción de escritura
  Wire.endTransmission();       // Finalizar transmisión al dispositivo
  Wire.beginTransmission(SHTC3_ADDRESS);
  Wire.write(byte(0x35));       // Enviar parte alta de la instrucción de despertar
  Wire.write(byte(0x17));       // Enviar parte baja de la instrucción de despertar
  Wire.endTransmission();
  delayMicroseconds(300);       // Retraso de 300 microsegundos
  Wire.beginTransmission(SHTC3_ADDRESS);
  Wire.write(byte(0xE0));
  Wire.endTransmission();
  Wire.beginTransmission(SHTC3_ADDRESS);
  Wire.write(byte(0x7C));       // Enviar parte alta de la instrucción de adquisición
  Wire.write(byte(0xA2));       // Enviar parte baja de la instrucción de adquisición
  Wire.endTransmission();
  Wire.beginTransmission(SHTC3_ADDRESS);
  Wire.write(byte(0xE1));       // Enviar instrucción de lectura
  Wire.endTransmission();
  Wire.requestFrom(SHTC3_ADDRESS,6);     // Solicitar datos al dispositivo esclavo
  uint16_t T_temp, RH_temp, T_CRC, RH_CRC;
  if (2 <= Wire.available()) {
    T_temp = Wire.read();     // Leer dato alto de temperatura
    T_temp = T_temp << 8;     // Desplazar 8 bits a la izquierda
    T_temp |= Wire.read();    // Operación OR bit a bit entre el dato alto desplazado y el dato bajo de temperatura recibido
    T_CRC = Wire.read();      // Leer código CRC
    if(SHTC3_CRC_CHECK(T_temp,T_CRC)){  // Verificar datos
      T = float(T_temp) * 175 / 65536 - 45;  // Calcular temperatura
    }
  }//https://blog.zeruns.com
  if (2 <= Wire.available()) {
    RH_temp = Wire.read();     // Leer dato alto de humedad
    RH_temp = RH_temp << 8;     // Desplazar 8 bits a la izquierda
    RH_temp |= Wire.read();    // Operación OR bit a bit entre el dato alto desplazado y el dato bajo de humedad recibido
    RH_CRC = Wire.read();
    if(SHTC3_CRC_CHECK(RH_temp,RH_CRC)){
      RH = float(RH_temp) * 100 / 65536;
    }
  }
}
//https://blog.zeruns.com
uint8_t SHTC3_CRC_CHECK(uint16_t DAT, uint8_t CRC_DAT) // Verificación CRC del SHTC3
{
    uint8_t i, t, temp;
    uint8_t CRC_BYTE;  
    CRC_BYTE = 0xFF;  
    temp = (DAT >> 8) & 0xFF;  
    for(t = 0; t < 2; t ++)
    {
        CRC_BYTE ^= temp;
        for(i = 0; i < 8; i ++)
        {
            if(CRC_BYTE & 0x80)
            {
                CRC_BYTE <<= 1;         
                CRC_BYTE ^= 0x31;  
            }else{
                CRC_BYTE <<= 1;  
            }
        }  
        if(t == 0)
        {
            temp = DAT & 0xFF; 
        }
    }//https://blog.zeruns.com  
    if(CRC_BYTE == CRC_DAT)
    {
        temp = 1;  
    }else{
        temp = 0;  
    }   
    return temp;
}

### Uso de la biblioteca SHTC3

Instale primero la biblioteca `SparkFun SHTC3`.

```c
/* https://blog.zeruns.com
 * Conexión
 * SHTC3    Placa de desarrollo
 * SCL      SCL (en la placa NodeMcu es D1)
 * SDA      SDA (en la placa NodeMcu es D2)
 */

#include <SparkFun_SHTC3.h>

SHTC3 mySHTC3;

void setup(){ // Función de inicialización, se ejecuta solo una vez al inicio del programa
  Serial.begin(115200);   // Configurar la velocidad del puerto serie
  while(Serial == false){};   // Esperar a que se inicie la conexión serial
  Wire.begin();           // Inicializar la biblioteca Wire (I2C)
  unsigned char i=0;
  errorDecoder(mySHTC3.begin());// Para iniciar el sensor, debe llamar a "begin()", la configuración predeterminada usa Wire (puerto I2C predeterminado de Arduino)
}
//https://blog.zeruns.com
void loop() {
  float RH, T;
  delay(1000);                  // Retraso de 1000 milisegundos
  SHTC3_Status_TypeDef result = mySHTC3.update();
  if(mySHTC3.lastStatus == SHTC3_Status_Nominal)   // Verificar si el estado del SHTC3 es normal
  {
    RH = mySHTC3.toPercent();   // Leer datos de humedad                
    T = mySHTC3.toDegC();       // Leer datos de temperatura             
  }else{
    Serial.print("Actualización fallida, error: ");
    errorDecoder(mySHTC3.lastStatus); // Mostrar razón del error
    Serial.println();
  }
  Serial.print("Humedad:");  // Imprimir "Humedad:" por el puerto serie
  Serial.print(RH);           // Imprimir datos de humedad por el puerto serie
  Serial.print("%");
  Serial.print("  Temperatura:");
  Serial.print(T);            // Imprimir datos de temperatura por el puerto serie
  Serial.println("C"); 
  Serial.println("https://blog.zeruns.com");
}

void errorDecoder(SHTC3_Status_TypeDef message) // La función errorDecoder imprime los resultados de "SHTC3_Status_TypeDef" de forma amigable
{
  switch(message)
  {
    case SHTC3_Status_Nominal : Serial.print("Nominal"); break;
    case SHTC3_Status_Error : Serial.print("Error"); break;
    case SHTC3_Status_CRC_Fail : Serial.print("Fallo CRC"); break;
    default : Serial.print("Código de retorno desconocido"); break;
  }
}

Vista previa del resultado

725×500 22.1 KB

Compra del sensor

DHT11: Copie $Lk3h1Mx8UTO$ para abrir Taobao en el móvil y realizar el pedido inmediatamente

DHT22: Copie $kr2T1MxkUKY$ para abrir Taobao en el móvil y realizar el pedido inmediatamente

SHTC3: Copie $UD4D1Mx6N3R$ para abrir Taobao en el móvil y realizar el pedido inmediatamente

Lecturas recomendadas:

  • Recomendaciones de VPS/ servidor en la nube de alto rendimiento y bajo costo: https://blog.zeruns.com/archives/383.html
  • Configurar un servidor de túnel de red interna con panel web: https://blog.zeruns.com/archives/397.html
  • Crear un disco personalizado con Cloudreve: https://blog.zeruns.com/archives/515.html
  • Cómo crear un blog personal: https://blog.zeruns.com/archives/218.html
  • Beneficios para estudiantes: https://blog.zeruns.com/archives/321.html
  • Comparto un pequeño juego que te puede generar ingresos: https://blog.zeruns.com/archives/472.html
1 me gusta