Sensor DHT22 da lecturas nan

Saludos, tengo un proyecto de medición de temperatura, humedad y consumo de unos cuartos de refrigeración, cuando parecía que ya estaba funcionando bien he empezado a tener lecturas "NAN" e el sensor de temperatura DHT22, pero solo sucede cuando el sensor de corriente empieza a "trabajar" es decir, cuando el motor del cuarto de refrigeración se activa, o después de que se apaga, el sensor dht22 empieza a dar las lecturas nan, no hay un momento exacto, puede encenderse o apagarse el cuarto de refrigeración varias veces y la lectura sigue normal, pero llega un momento que empieza a fallar el dht22 y solo se soluciona desconectando completamente la placa arduino de la corriente y volviéndola a encender.

Probé una solución que mire en otro foro que era alimentar el sensor por medio de un pin digital y en cuanto el sensor empiece da dar lecturas NAN cambiar el estado a LOW del pin que alimenta el sensor y luego volver a darle HIGh, pero no me ha funcionado, así tengo las conexiones:

Y el código que uso es este: (no soy el mejor programando, aún estoy aprendiendo.)

#include "DHT.h"
#include <SPI.h>
#include <Ethernet.h>
#include <Wire.h>
#include <Adafruit_ADS1015.h>
#include <Adafruit_MLX90614.h>
#include <math.h>

#define DHTPIN1 2 //TEMPERATURA 1
#define DHTPIN2 3 //TEMPERATURA 2
#define DHTTYPE DHT22
DHT dht1(DHTPIN1,DHTTYPE); // inicializar sensor de temperatura 1
DHT dht2(DHTPIN2,DHTTYPE); // inicializar sensor de temperatura 2

unsigned long tiempoActual = 0; // Variable para almacenar el tiempo actual
unsigned long tiempoAnterior = 0; // Variable para almacenar el último tiempo en que se ejecutó el loop()
const unsigned long intervalo = 100000; // Intervalo de tiempo deseado para ejecutar el loop() (5 minutos en milisegundos)
int valorpuerta1anterior = LOW; // Variable para almacenar el último estado del sensor de la puerta
int valorpuerta2anterior = LOW; // Variable para almacenar el último estado del sensor de la puerta
int valorpuerta3anterior = LOW; // Variable para almacenar el último estado del sensor de la puerta
int valorpuerta4anterior = LOW; // Variable para almacenar el último estado del sensor de la puerta

// Instanciar objeto ADS
Adafruit_ADS1115 ads(0x48);

//definir variables de conversion de consumo  
const float FACTOR = 50; //30A/1V
const float multiplier = 0.0495F;

int entradapuerta1 = 8; // entrada de puerta 1
int entradapuerta2 = 9; // entrada de puerta 2
int entradapuerta3 = 4; // entrada de puerta 1
int entradapuerta4 = 5; // entrada de puerta 2

float humidityData1;
float temperatureData1;
float humidityData2;
float temperatureData2;
float consumo;
float potencia;
int punto;
int cuarto;
int puerta1;
int puerta2;
int valorpuerta1 = 0; //puerta de cuanto frio 1
int valorpuerta2 = 0; //puerta de cuanto frio 2
int valorpuerta3 = 0; //puerta de cuanto frio 1
int valorpuerta4 = 0; //puerta de cuanto frio 2

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
char server[] = "180.81.1.255";    // name address for Google (using DNS)

IPAddress ip(192, 110, 40, 145);
IPAddress myDns(192, 110, 40, 105);

EthernetClient client;

// Variables to measure the speed
unsigned long beginMicros, endMicros;
unsigned long byteCount = 0;
bool printWebData = true;  // set to false for better speed measurement

void setup() {

  Serial.begin(9600);
  dht1.begin();
  dht2.begin();
  pinMode(entradapuerta1, INPUT); //seteamos la puerta 1 como entrada
  pinMode(entradapuerta2, INPUT); //seteamos la puerta 2 como entrada
  pinMode(entradapuerta3, INPUT); //seteamos la puerta 1 como entrada
  pinMode(entradapuerta4, INPUT); //seteamos la puerta 2 como entrada
  ads.setGain(GAIN_TWO);        // ±2.048V  1 bit = 0.0625mV
  ads.begin();
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  // start the Ethernet connection:
  Serial.println("Initialize Ethernet with DHCP:");
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // Check for Ethernet hardware present
    if (Ethernet.hardwareStatus() == EthernetNoHardware) {
      Serial.println("Ethernet shield was not found.  Sorry, can't run without hardware. :(");
      while (true) {
        delay(1); // do nothing, no point running without Ethernet hardware
      }
    }
    if (Ethernet.linkStatus() == LinkOFF) {
      Serial.println("Ethernet cable is not connected.");
    }
    // try to configure using IP address instead of DHCP:
    Ethernet.begin(mac, ip, myDns);
  } else {
    Serial.print("DHCP assigned IP ");
    Serial.println(Ethernet.localIP());
  }
  // give the Ethernet shield a second to initialize:
  delay(1000);
  Serial.print("connecting to ");
  Serial.print(server);
  Serial.println("...");
}

void loop() {

  tiempoActual = millis(); // Actualizar el tiempo actual

  if (tiempoActual - tiempoAnterior >= intervalo) { // Verificar si ha pasado el tiempo deseado
    tiempoAnterior = tiempoActual; // Actualizar el último tiempo en que se ejecutó el loop()
    // Código que se ejecutará cada 5 minutos
    valorpuerta1 = digitalRead(entradapuerta1);
    valorpuerta2 = digitalRead(entradapuerta2);
    valorpuerta3 = digitalRead(entradapuerta3);
    valorpuerta4 = digitalRead(entradapuerta4);
    lectura1();
  }// fin del if de intervalo

  // cuando la puerta se abra volvemos a leer todos los datos
  valorpuerta1 = digitalRead(entradapuerta1);
  valorpuerta2 = digitalRead(entradapuerta2);
  valorpuerta3 = digitalRead(entradapuerta3);
  valorpuerta4 = digitalRead(entradapuerta4);

  if (valorpuerta1 != valorpuerta1anterior || valorpuerta2 != valorpuerta2anterior || valorpuerta3 != valorpuerta3anterior || valorpuerta4 != valorpuerta4anterior) { // Verificar si ha cambiado el estado del sensor de la puerta
    valorpuerta1anterior = valorpuerta1; // Actualizar el último estado del sensor de la puerta
    valorpuerta2anterior = valorpuerta2; // Actualizar el último estado del sensor de la puerta
    valorpuerta3anterior = valorpuerta3; // Actualizar el último estado del sensor de la puerta
    valorpuerta4anterior = valorpuerta4; // Actualizar el último estado del sensor de la puerta
    lectura1();
  }
}

float getCorriente1(){
  float Volt_diferencial1;
  float corriente1;
  float sum = 0;
  long tiempo = millis();
  int counter = 0;
 
  while (millis() - tiempo < 1000)
  {
    Volt_diferencial1 = ads.readADC_Differential_0_1() * multiplier;
   
   //-----------------------------------------------------
   //Volt_diferencial = ads.readADC_Differential_2_3() * multiplier;
   //-----------------------------------------------------
   
   corriente1 = Volt_diferencial1 * FACTOR;
   corriente1 /= 1000.0;
 
   sum += sq(corriente1);
   counter = counter + 1;
  }
  corriente1 = sqrt(sum / counter);
  return(corriente1);
}

float getCorriente2(){
  float Volt_diferencial2;
  float corriente2;
  float sum = 0;
  long tiempo = millis();
  int counter = 0;
 
  while (millis() - tiempo < 1000)
  {
    //Volt_diferencial = ads.readADC_Differential_0_1() * multiplier;
   
   //-----------------------------------------------------
   Volt_diferencial2 = ads.readADC_Differential_2_3() * multiplier;
   //-----------------------------------------------------
   
   corriente2 = Volt_diferencial2 * FACTOR;
   corriente2 /= 1000.0;
 
   sum += sq(corriente2);
   counter = counter + 1;
  }
  corriente2 = sqrt(sum / counter);
  return(corriente2);
}

void lectura1(){
    float CorrienteRMS1 = getCorriente1();
    float Potencia = 120.0 * CorrienteRMS1;
  
    float CorrienteRMS2 = getCorriente2();
    float Potencia2 = 120.0 * CorrienteRMS2;
  
    if (valorpuerta1 == HIGH && valorpuerta2 == HIGH) {
      Serial.println("cerrada completamente");
      puerta1 = 1;
    }
    if(valorpuerta1 == LOW && valorpuerta2 == HIGH){
      Serial.println("cerrada a medias");
      puerta1 = 2;
    }
    if(valorpuerta1 == HIGH && valorpuerta2 == LOW){
      Serial.println("cerrada a medias");
      puerta1 = 2;
    }
    if (valorpuerta1 == LOW && valorpuerta2 == LOW) {
      Serial.println("ABIERTA");
      puerta1 = 3;
    }
    if (valorpuerta3 == HIGH && valorpuerta4 == HIGH) {
      Serial.println("cerrada completamente");
      puerta2 = 1;
    }
    if(valorpuerta3 == LOW && valorpuerta4 == HIGH){
      Serial.println("cerrada a medias");
      puerta2 = 2;
    }
    if(valorpuerta3 == HIGH && valorpuerta4 == LOW){
      Serial.println("cerrada a medias");
      puerta2 = 2;
    }
    if (valorpuerta3 == LOW && valorpuerta4 == LOW) {
      Serial.println("ABIERTA");
      puerta2 = 3;
    }
    humidityData1 = dht1.readHumidity();
    temperatureData1 = dht1.readTemperature();

    humidityData2 = dht2.readHumidity();
    temperatureData2 = dht2.readTemperature();

    if (client.connect(server, 80)) {//REGISTROS CUARTO FRIO 1 CONGELACION
      
      if (isnan(humidityData1)) {
          Serial.println("Error al leer el sensor DHT22");
          digitalWrite(DHTPIN2, LOW);
          digitalWrite(DHTPIN1, LOW);
          delay(1000);                                        // demosle unos instantes para que todo se estabilice.
          digitalWrite(DHTPIN2, HIGH);
          digitalWrite(DHTPIN1, HIGH);  // Listo otra vez energizado.
      }
      consumo= CorrienteRMS1;
      potencia= Potencia;
      punto=1;
      cuarto=1;
      //Serial.print("connected to ");
      //Serial.println(client.remoteIP());
      // Make a HTTP request:
      Serial.print("GET /anadir.php?humidity=");
      client.print("GET /anadir.php?humidity="); 
      Serial.print(humidityData1);
      client.print(humidityData1);
      client.print("&temperature=");
      Serial.print("&temperature=");
      client.print(temperatureData1);
      Serial.print(temperatureData1);
      client.print("&consumo=");
      Serial.print("&consumo=");
      client.print(consumo);
      Serial.print(consumo);
      client.print("&puerta=");
      Serial.print("&puerta=");
      client.print(puerta1);
      Serial.print(puerta1);
      client.print("&cuarto=");
      Serial.print("&cuarto=");
      client.print(cuarto);
      Serial.print(cuarto);
      client.print("&punto=");
      Serial.print("&punto=");
      client.print(punto);
      Serial.print(punto);
      client.println(" HTTP/1.1");
      client.println("Host: MIDOMINIO.com.co");
      client.println();
      Serial.println();
      //REGISTROS DE CUARTO FRIO 2 REFRIGERACION
      
      if (isnan(humidityData2)) {
          Serial.println("Error al leer el sensor DHT22");
          digitalWrite(DHTPIN2, LOW);
          digitalWrite(DHTPIN1, LOW);
          delay(1000);                                        // demosle unos instantes para que todo se estabilice.
          digitalWrite(DHTPIN2, HIGH);
          digitalWrite(DHTPIN1, HIGH);  // Listo otra vez energizado.
      }
      consumo= CorrienteRMS2;
      potencia=Potencia2;
      punto=1;
      cuarto=2;
      //Serial.print("connected to ");
      //Serial.println(client.remoteIP());
      // Make a HTTP request:
      Serial.print("GET /anadir.php?humidity=");
      client.print("GET /anadir.php?humidity="); 
      Serial.print(humidityData2);
      client.print(humidityData2);
      client.print("&temperature=");
      Serial.print("&temperature=");
      client.print(temperatureData2);
      Serial.print(temperatureData2);
      client.print("&consumo=");
      Serial.print("&consumo=");
      client.print(consumo);
      Serial.print(consumo);
      client.print("&puerta=");
      Serial.print("&puerta=");
      client.print(puerta2);
      Serial.print(puerta2);
      client.print("&cuarto=");
      Serial.print("&cuarto=");
      client.print(cuarto);
      Serial.print(cuarto);
      client.print("&punto=");
      Serial.print("&punto=");
      client.print(punto);
      Serial.print(punto);
      client.println(" HTTP/1.1");
      client.println("Host: MIDOMINIO.com.co");
      client.println("Connection: close");
      client.println();
      Serial.println();
    } else {
      // if you didn't get a connection to the server:
      Serial.println("connection failed");
    }
    beginMicros = micros();

    int len = client.available();
    if (len > 0) {
      byte buffer[80];
      if (len > 80) len = 80;
      client.read(buffer, len);
      if (printWebData) {
        Serial.write(buffer, len); // show in the serial monitor (slows some boards)
      }
      byteCount = byteCount + len;
    }
    // if the server's disconnected, stop the client:
    if (!client.connected()) {
      Serial.println("Conexión perdida.");
      if (Ethernet.linkStatus() == LinkON) {   // Si el cable Ethernet está conectado
        Serial.println("Intentando reconectar...");
        client.connect(server, 80);            // Intentar reconectar al servidor
        delay(1000);
      }
    }
}

Olvide mencionar, que también tengo unos sensores de contacto magnéticos que controlan si la puerta se abre.

Agradezco mucho su ayuda.

¿Te confundiste de código o el esquema está incompleto?
Verifícalo.

Se entiende que el sensor DHT22 funciona bien y falla solo si el sensor de corriente entra en operación, pero más bien sería que los motores de refiregeración se activan.

Bajo lo que mencionas diria que es ruido, sin embargo no se define que sensor de corriente estas utilizando porque tengo entendido por el datasheet del SCT013 que tiene dos modelos uno que es salida en corriente y otro es salida en voltaje.

image

Bajo esto no comprendo que metodo de lectura estas utilizando mediante la conexión entre el Arduino y el ADS1115, ya que la mayoria de tutoriales dicen que ese sensor entrega una salida sinusoidal en valores positivos y negativos, tal como este proyecto: SCT-013 mide el consumo eléctrico en tu casa con Arduino, siendo así que se necesitaría añadir un circuito similar al de la imagen, que "mueve" la salida sinusoidal a valores positivos para operar este tipo de sensor de acuerdo a la corriente pico que quisieras medir
image

El ADS está trabajando en modo diferencial.

Saludos

El problema lo tiene con el DHT22. Es un problema conocido que estoy seguro se debe a que se trata de un clon del DHT22, uno que tenemos casi todos. Yo tmb he experimientado ese problema y tmb lo he apagado y encendido pero el problema persiste.
Nada me ha funcionado en el tiempo.

En el mismo circuito he adicionado un sensor ds18b20 encapsulado el cual trabaja sin ningún problema mientras que el dht22 sigue con sus lecturas nan, definitivamente es problema del dht, el problema es que es ds18b20 solo mide temperatura mas no humedad.. sabes si hay algún sensor que trabaje igual al ds18b20 pero que a la vez mida humedad?

Yo uso 2 y tengo el mismo problema, cuando muevo persianas motorizadas empiezan a dar lecturas NaN, a los 4 NaN le corto alimentacion medio segundo con un rele y hasta el proximo movimiento. La humedad tampoco es muy fiable.
He probado con cable de 1mm, poniendo resistencia pullup en el dht, en la entrada y poniendo ferrita pasa lo mismo.
Ahora leo tambien sensores Xiaomi BLE.

El sensor DHT22 y sus hermanos AM2302 y DHT11 se han vuelvo poco confiables, creo yo que porque son todos falsas copias de los orignales.
En realidad no encaré mas proyectos con nada que lo contemple.
Ahora estoy considerando usar dos DS18b20, conformando un sistema de medicion de humedad.
Cómo es eso?
Pues bien, alguien con el mismo problema recibió el comentario en un foro de que usando un psicrómetro usa dos termómetros. Uno llamado bulbo seco y otro bulbo húmedo.
Cito a Pablo E. Untroib

La humedad relativa se calcula por la diferencia de temperatura entre ambas mediciones.
De Wikipedia: El húmedo es sensible a la evaporación de agua, y debido al enfriamiento que produce la evaporación, medirá una temperatura inferior. Si hay poca diferencia entre una y otra temperatura, hay poca evaporación, lo cual indica que la humedad relativa es alta. Si hay mucha diferencia, hay mucha evaporación, lo cual indica que la humedad relativa es baja. Con estos dos valores se puede ver la humedad en una carta psicrométrica o bien se pueden calcular con una formula, que es lo que hice yo.

Para mas precision, la formula contempla la presión atmosférica, que la mido con otro sensor.
Les muestro en el video mi banco de prueba, en una pantalla muestro ambas temperaturas y el calculo de la humedad.
La otra pantalla es el termo higrómetro que intento calibrar.
Utilice dos sensores Dallas DS18b20 que verifique previamente lean parejo (diferencia menor a 0.5C) y un cooler de 30mm que tenia dando vueltas por ahi.
lo envolví en papel tissue y le tire unas cuantas gotas, luego de mas de 10 minutos sigue húmedo y midiendo parejo.
Ahora a diseñar y poner todo en una linda cajita impresa 3D.
Recien al hacer el video me di cuenta que los valores no estan alineados...
Como se que alguien con problemas de TOC lo va a mencionar, listo, lo arreglé

https://twitter.com/peu_ar/status/1644441157554827264?s=46&t=BShZzv9TUG9vKYKOBWpHtw

Lean lo que dicen del BMP280 como alternativa pero luego el mismo de los DS18B20 que cito dice que hay 12% de diferencia.. complicado el tema.

La idea del proyecto que estoy realizando surgio de un montaje que mire en otro lugar, alli tenian estos dispositivos dentro de los cuartos de refrigeracion:


sé que uno es un PIR, y el otro debería ser un sensor de temperatura, que atando cabos, sería el que yo debería usar peor no tengo ni idea que modelo o refencia es, porque según vi en la instalación de este va alimentado por el arduino y directamente a un pin digital, así sin más..

Se parece al TH-MB-02S, pero ese usa comunicación Modbus.

TH-MB-02S

Un detalle: Este se ajusta usando valores de corrección para T y H que se suman o restan al valor leído. ¿Te suena? :wink: