Moniteur série et DHT11.

Bonjour, je rencontre un problème avec mon DHT11, lorsque je met le moniteur série j’ai ceci qui s’affiche:

Za⸮⸮Zk⸮⸮J(⸮⸮J)⸮⸮'SJ(⸮⸮Zk⸮⸮j⸮~⸮bH⸮⸮bh⸮⸮J)⸮⸮gHSZk⸮⸮bh⸮⸮J)⸮⸮Zk⸮⸮gHS⸮3GgH⸮bh⸮⸮J)⸮⸮Zk⸮⸮Za⸮⸮3Gz⸮~⸮gHS⸮⸮bh⸮⸮j⸮~⸮⸮a⸮⸮bh⸮⸮⸮a⸮⸮⸮⸮Za⸮⸮3G⸮'SgH⸮⸮J)⸮⸮⸮a⸮⸮Za⸮⸮Zk⸮⸮'SJ(⸮⸮J(⸮⸮bh⸮⸮j⸮~⸮Zk⸮

Pourriez-vous me dire pourquoi je n’arrive pas à voir les valeurs mesurées par le capteur ?
J’utilise ce code:

#include <DHTesp.h>

const byte DHT11_PIN = A5;
 
/** Code d'erreur de la fonction readDHT11() */
enum {
  DHT11_SUCCESS, //!< Pas d'erreur
  DHT11_TIMEOUT_ERROR, //!< Temps d'attente dépassé
  DHT11_CHECKSUM_ERROR //!< Données reçues erronées
};
 
/** Fonction setup() */
void setup() {
   
  /* Initialisation du port série */
  Serial.begin(57600);
  Serial.println(F("DHT11 DEMO"));
}
 
/** Fonction loop() */
void loop() {
 
  /* Variables d'usage */
  byte temperature, humidity;
 
  /* Lecture de la température et de l'humidité + gestion des erreurs */
  switch (readDHT11(DHT11_PIN, &temperature, &humidity)) {
  case DHT11_SUCCESS:
     
    /* Affichage de la température et du taux d'humidité */
    Serial.print(F("Humidite (%): "));
    Serial.println((int) humidity);
    Serial.print(F("Temperature (^C): "));
    Serial.println((int) temperature);
    break;
 
  case DHT11_TIMEOUT_ERROR:
    Serial.println(F("Temps d'attente depasse !"));
    break;
 
  case DHT11_CHECKSUM_ERROR:
    Serial.println(F("Erreur de checksum !"));
    break;
  }
   
  /* Pas besoin de rafraichir l'affichage très souvent */
  delay(2000);
}
 
/**
 * Lit la température et le taux d'humidité capté par un capteur DHT11
 *
 * @param pin Broche sur laquelle est câblé le capteur
 * @param temperature Pointeur vers la variable stockant la température
 * @param humidity Pointeur vers la variable stockant le taux d'humidité
 * @return DHT11_SUCCESS si aucune erreur, DHT11_TIMEOUT_ERROR en cas de timeout, ou DHT11_CHECKSUM_ERROR en cas d'erreur de checksum
 */
byte readDHT11(byte pin, byte* temperature, byte* humidity) {
 
  /* data[] -> buffer contenant les données du cpateur
   * counter -> compteur permettant de savoir quel bit est reçu (bitwise)
   * index -> compteur permettant de savoir quel octet est reçu (bitwise)
   * timeout -> compteur pour le timeout
   */
  byte data[5] = { 0 }, counter = 7, index = 0;
  unsigned int timeout;
 
  /* Conversion du numéro de broche Arduino en ports/masque binaire "bas niveau" */
  /* Utiliser les registres du microcontrôleur est bien plus rapide que digitalWrite() */
  //uint8_t bit = digitalPinToBitMask(pin);
  //uint8_t port = digitalPinToPort(pin);
 
  uint16_t bit = digitalPinToBitMask(pin);
  uint8_t port = digitalPinToPort(pin);
  volatile uint8_t *ddr = portModeRegister(port); // Registre MODE (INPUT / OUTPUT)
  volatile uint8_t *out = portOutputRegister(port); // Registre OUT (écriture)
  volatile uint8_t *in = portInputRegister(port); // Registre IN (lecture)
 
  /* Réveil du capteur */
  *ddr |= bit; // OUTPUT
  *out &= ~bit; // LOW
  delay(18); // Temps d'attente à LOW causant le réveil du capteur
  *out |= bit; // HIGH
  delayMicroseconds(40);
  *ddr &= ~bit; // INPUT
 
  /* Attente de la réponse du capteur */
  timeout = 0;
  while(!(*in & bit)) /* Attente d'un état LOW */
    if (++timeout == 10000)
      return DHT11_TIMEOUT_ERROR;
  timeout = 0;
  while(*in & bit) /* Attente d'un état HIGH */
    if (++timeout == 10000)
      return DHT11_TIMEOUT_ERROR;
 
  /* Lecture des données du capteur (40 bits) */
  for (byte i = 0; i < 40; ++i) {
 
    /* Attente d'un état LOW */
    timeout = 0;
    while(!(*in & bit))
      if (++timeout == 10000)
        return DHT11_TIMEOUT_ERROR;
 
    /* Mise en mémoire du temps courant */
    unsigned long t = micros();
 
    /* Attente d'un état HIGH */
    timeout = 0;
    while(*in & bit)
      if (++timeout == 10000)
        return DHT11_TIMEOUT_ERROR;
 
    /* Si le delta Temps est supérieur à 40µS c'est un "1", sinon c'est un "0" */
    if ((micros() - t) > 40)
      data[index] |= (1 << counter); // "1"
    // Le tableau data[] est initialisé à "0" par défaut <span title=";)" class="wp-smiley emoji emoji-wink">;)</span>
 
    /* Si le compteur de bits atteint zéro */
    if (counter-- == 0) {
      counter = 7; /* On passe à l'octet suivant */
      ++index;
    }
  }
 
  /* Format des données :
   * ◦ = humidité en %

   * [1] = zéro
   * [2] = température en degrés Celsius
   * [3] = zéro
   * [4] = checksum (humidité + température)
   */
  *humidity = data[0];
  *temperature = data[2];
 
  /* Vérifie la checksum */
  if (data[4] != (data[0] + data[2]))
    return DHT11_CHECKSUM_ERROR; /* Erreur de checksum */
  else
    return DHT11_SUCCESS; /* Pas d'erreur */
}

Bonjour,

Vérifies que ton moniteur série soit bien configuré à la même vitesse que dans ton programme, soit 57600 bds.

Merci, effectivement ça va mieux mais du coup j'ai ceci "DHT11 DEMO Erreur de checksum !"

Tu as bien une résistance de pullup de 4.7k?
Vérifies ton cablage.

Il y en a déjà une sur ce type de carte non ?

Oui, apparemment.

DTHxy et erreur checksum = mauvaise bibliothèque.

Les DHT sont des circuits rapides. A l’intérieur il y a un microcontrôleur qui envoie les valeurs de température et d'humidité.
Celui qui a pondu ce circuit était bien conscient qu'il fallait lire ce produit rapidement, il a ajouté une somme de contrôle pour vérifier que la lecture s'est faite sans erreur.

La communication est codée. Le DHT envoie toujours un couple de deux éléments binaires ( un 0 suivi d'un 1) pour indiquer un bit d'information 0 ou 1.
Si le bit d'information est un 0 : la longueur de l'élément binaire 1 est plus courte que celle du 0.
Si le bit d'information est un 1 : la longueur de l'élément binaire 1 est plus longue que celle du 0.

Par couple d'éléments binaires envoyé le "jeu" consiste à comparer la longueur d'un 1 par rapport a celle d'un 0 pour pouvoir dire si on a affaire à un 0 ou a un 1.

La fonction Wiring digitalRead(), reprise par arduino, s'exécute à la vitesse d'un escargot et provoque de nombreuse erreur de lecture et donc à la fin un "Check Sum Error".

Tu as probablement une ancienne bibliothèque qui utilise digitalRead().
Cherches en une plus moderne qui ira lire directement les registres des entrées de la carte Arduino.

Indice : chercher du coté de Rob Tillaart.

Bonjour merci, je trouve la bibliothèque de Rob Tillaart sous forme de texte, je veux dire pas sous forme de lien téléchargeable est-ce que cela reviens au même ?

J’essaye de voir ce qu’il y a dans “le texte” dont tu nous parles :
boule_de_cristal.jpg
Je vois rien.
Tu ne crois pas que si tu avais mis un lien vers l’endroit où tu as télécharger il serait plus facile de te répondre.

Et si tu faisais une recherche sur le forum ? ==> l’icône en forme de loupe en haut et à droite.
Tu obtiendrais ceci :
https://www.google.com/search?q=DHT22+rob+tillart&domains=https%3A%2F%2Fforum.arduino.cc&sitesearch=https%3A%2F%2Fforum.arduino.cc

où tu pourrait sans aucun doute télécharger une bibliothèque aux normes de l’IDE.

Autre possibilité :
Adafruit a mis sa bibliothèque à jour en forkant celle de Rob, elle fonctionne très bien.

Je parle de ce “texte” là :

 //
//     FICHIER: dht.h
//   AUTEUR: Rob Tillaart
// VERSION: 0.1.29
// OBJECTIF: Bibliothèque de capteurs de température et d'humidité DHT pour Arduino
//      URL: http://arduino.cc/playground/Main/DHTLib
//
// HISTOIRE:
// voir le fichier dht.cpp
//

# ifndef dht_h
# définir  dht_h

# si ARDUINO <100
# inclut  < WProgram.h >
# include  < pins_arduino.h >   // correction pour la version pré 1.0 cassée - TODO TEST
# else
# inclure  < Arduino.h >
# endif

# définir  DHT_LIB_VERSION  " 0.1.29 "

# définir  DHTLIB_OK                    0
# define  DHTLIB_ERROR_CHECKSUM        - 1
# define  DHTLIB_ERROR_TIMEOUT         - 2
# define  DHTLIB_ERROR_CONNECT         - 3
# définir  DHTLIB_ERROR_ACK_L           - 4
# définir  DHTLIB_ERROR_ACK_H           - 5

# définir  DHTLIB_DHT11_WAKEUP          18
# définir  DHTLIB_DHT_WAKEUP            1

# définir  DHTLIB_DHT11_LEADING_ZEROS   1
# définir  DHTLIB_DHT_LEADING_ZEROS     6

// le délai maximum est de 100 usec.
// Pour un 16 Mhz proc 100 usec c'est 1600 cycles d'horloge
// les boucles utilisant DHTLIB_TIMEOUT utilisent au moins 4 cycles d'horloge
// donc 100 us prend max 400 boucles
// donc en divisant F_CPU par 40000 on "échoue" aussi vite que possible
# ifndef F_CPU
# définir  DHTLIB_TIMEOUT  1000   // doit être env. horloge / 40000
# else
# définir  DHTLIB_TIMEOUT (F_CPU / 40000 )
# endif

classe  dht
{
Publique:
    dht () {_disableIRQ = false ; };
    // renvoie des valeurs:
    // DHTLIB_OK
    // DHTLIB_ERROR_CHECKSUM
    // DHTLIB_ERROR_TIMEOUT
    // DHTLIB_ERROR_CONNECT
    // DHTLIB_ERROR_ACK_L
    // DHTLIB_ERROR_ACK_H
    int8_t  read11 ( broche uint8_t );
     lecture int8_t ( broche uint8_t );
    int8_t  read12 ( broche uint8_t );

    inline  int8_t  read21 ( broche uint8_t ) { return  read (broche); };
    inline  int8_t  read22 ( uint8_t pin) { return  read (pin); };
    inline  int8_t  read33 ( broche uint8_t ) { return  read (broche); };
    inline  int8_t  read44 ( broche uint8_t ) { return  read (broche); };
    inline  int8_t  read2301 ( uint8_t pin) { return  read (pin); };
    inline  int8_t  read2302 ( uint8_t pin) { return  read (pin); };
    inline  int8_t  read2303 ( pin uint8_t ) { return  read (pin); };
    inline  int8_t  read2320 ( broche uint8_t ) { return  read (broche); };
    inline  int8_t  read2322 ( uint8_t pin) { return  read (pin); };
    
    bool  getDisableIRQ () { return _disableIRQ; };
    void  setDisableIRQ ( bool b) {_disableIRQ = b; };

    humidité flottante ;
    température flottante ;

privé:
    uint8_t bits [ 5 ];  // tampon pour recevoir les données
    int8_t  _readSensor ( broche uint8_t , uint8_t wakeupDelay, uint8_t LeadingZeroBits);
    bool    _disableIRQ;
};
# endif
//
// FIN DE FICHIER
//

Mais est-ce que le fait de l’intégrer tel quel dans le code fait le même effet que “inclure une bibliothèque” ?

Tu télécharges la librairie ici

Motobilette007:
Je parle de ce “texte” là :

 //

//     FICHIER: dht.h
//   AUTEUR: Rob Tillaart
// VERSION: 0.1.29
// OBJECTIF: Bibliothèque de capteurs de température et d’humidité DHT pour Arduino
//      URL: http://arduino.cc/playground/Main/DHTLib
//
// HISTOIRE:
// voir le fichier dht.cpp
//




Mais est-ce que le fait de l'intégrer tel quel dans le code fait le même effet que "inclure une bibliothèque" ?

Ça c’est le fichier *.h qui est le fichier d’entête (h pour header), c’est le moins important (il est quand même nécessaire).
Le plus important c’est le ou les fichiers *.cpp qui contiennent le code.

Une bibliothèque c’est un ensemble de fichiers.

Quand le compilateur rencontre un #include<abcd.h> il va chercher le reste des fichiers dans les répertoire que lui indique l’IDE.
C’est pour cela qu’il faut télécharger le fichier zip qui contient tous les fichiers de la bibliothèque ainsi que des fichiers exemples qui aident à comprendre comment on utilise la bibliothèque.

As tu lu les tuto d’Eskimon comme il est recommandé de faire ?
Il donne des explications très utiles, c’est pourquoi sa lecture est conseillé dans les messages épinglés.

D'accord, non effectivement je n'ai pas lu ces messages je vais essayé de trouver une bibliothèque téléchargeable et qui fonctionne. Merci beaucoup...