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 */
}
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.
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 :
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.
// 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.
