Go Down

Topic: PROBLEME d'acquisition température stable avec un DS18B20 (Read 817 times) previous topic - next topic

AIRPOPCIE

Bonjour en 2016 j'ai participé pour la première fois à un forum sur la régulation de température.
J'utilise des DS18B20 et la température lue chaque minute n'est pas très stable. Lorsque elle varie de 2 ou 3/10ème ce n'est pas trop grave vu que je régule en comparaison des Degrés, mais sur un des Capteur j'ai parfois plus d'un degré d'écart.

Même en modifiant le "delai" ce n'est pas stable.

Voici la partie acquisition et affichage sur le port com..
Code: [Select]

Topmesure = (millis()/1000%60);
 Topmesure1=Topmesure;
 switch (Topmesure)
  {
  case 0:
      if (Mesure1 == 0) {
   sensors.requestTemperatures();
 delay(200);
// TX = sensors.getTempC(TempX);
   printTemperature(sonde1);
 delay(50);
  valdigit1 = valdigit;
  TempS1 = TempS;
  Serial.print("temperature sonde N1 CAVE est: ");
  Serial.print("    ");
  Serial.print(TempS1);
  Serial.print("    ");
  Serial.print(" valdigit1 ");
  Serial.print(valdigit1);
  Serial.print("    ");
  Serial.print("\n\r");
       Mesure1 = 1;
       Mesure4 = 0;
    }
   break;
 
 case 15:
    if (Mesure2 == 0) {
   sensors.requestTemperatures();
 delay(200);
   printTemperature(sonde2);
    delay(50);
  valdigit2 = valdigit;
  TempS2 = TempS;
  Serial.print("temperature sonde N2 TOITURE est: ");
  Serial.print("    ");
  Serial.print(TempS2);
  Serial.print("    ");
  //valdigit2 =(valdigit2*(-1)); //pour tester les T° négative
  Serial.print(" valdigit2 ");
  Serial.print(valdigit2);
  Serial.print("\n\r");
       Mesure2 = 1;
       Mesure1 = 0;
      }
  break;
 
  case 30:
    if (Mesure3 == 0) {
   sensors.requestTemperatures();
 delay(200);
   printTemperature(sonde4);
    delay(50);
  valdigit4 = valdigit;
  TempS4 = TempS;
  Serial.print("temperature sonde N4 caisson  est: ");
  Serial.print("    ");
  Serial.print(TempS4);
  Serial.print("    ");
  Serial.print(" valdigit4 ");
  Serial.print(valdigit4);
  Serial.print("\n\r");
      Mesure3 = 1;
      Mesure2 = 0;
    }
   break;
 
  case 45:
      if (Mesure4 == 0){
    sensors.requestTemperatures();
 delay(20);
   printTemperature(sonde3);
    delay(50);
  valdigit3 = valdigit;
  TempS3 = TempS;
  Serial.print("temperature sonde N3 GRENIER  est: ");
  Serial.print("    ");
  Serial.print(TempS3);
  Serial.print("    ");
  //valdigit3 =(valdigit3*(-1)); //pour tester les T° négative
  Serial.print(" valdigit3 ");
  Serial.print(valdigit3);
  Serial.print("    ");
  Serial.print("Etat du relais de la climatisation:");
  Serial.print (Etatrelaisclimatisation);
  Serial.print("\n\r");
  Serial.print ("reponse  ");
  Serial.print (Reponse);
  Serial.print("\n\r");
       Mesure4 = 1;
       Mesure3 = 0;
      }
  break;
  }
     
   
 }



Si quelqu'un a une expérience merci d'avance de bien vouloir m'en faire profiter.
A vous lire et bonne arduinade..

infobarquee

bonjour,
résolution demandée dans le code?
longueur du cable?
montage?
lien librairie?
AUCUNE AIDE PAR MP

AIRPOPCIE

le montage est en one wire comme préconisé pour le DS18B20.
 
merci pour la réponse.

Les câbles font 1m ou 2.0m je donne l'intégralité du code tel qu'il tourne..
Merci
Code: [Select]

/**************************************************************
* -----------  Gestion de la cave du POP ---------------------*
* Prise de températures dans 3 points différents pour couper  *
* la climatisation en cas de surchauffe de l'évaporateur.     *
*       GESTION DE LA CAVE JeenodePoP du haut                 *
* Mai 2016     V9.2   Juin 2017 V 1.0                         *
**************************************************************/

#include <Wire.h>
#include <math.h>
#include <DallasTemperature.h>
#include <OneWire.h>

uint16_t startAddr = 0x0000;       // Adresse de démarrage Start dans  NV-RAM
uint16_t lastAddr;                 // Nelle addresse des stockage NV-RAM
uint16_t TimeIsSet = 0xaa55;       // Prévient qu'il n'y a pas de remise à l'heure

int  Topmesure = 0;
int  Topmesure1 = 0;
int  Topmesure2 = 0;
int  Topmesure3 = 0;
int  Topmesure4 = 0;
int  Mesure1 = 0;
int  Mesure2 = 0;
int  Mesure3 = 0;
int  Mesure4 = 0;

int compteur = 0;
int valdigit;
int valdigit1;//était valdigitS4
int valdigit2;//était valdigitS2
int valdigit3;//était valdigitS6
int valdigit4;//était valdigitS7
int tempC;
int Reponse;
int Clignotant;
int Defaut = 0;
int Etatrelaisclimatisation;
int sortitesimpulsion;
float coefficient = (1024/55);//1024/55°C
float TempS;
float TempS1;//était TempS4
float TempS2;//était TempS5
float TempS3;//était TempS6
float TempS4;//était TempS7

/*********************
 * ADRESSAGE DES PIN *
 *********************/

//Data wire connecté sur pin 2 de l'Arduino
#define ONE_WIRE_BUS   3 //Doit passer en 3 pour JnodePoPHaut
// Relais connectés sur pin 6 et 7.
#define Relaisclimatisation  4// Doit passer en 4 pour JnodePoPHaut
#define sortitesimpulsion 5

/*********************************************************************
 * Déclaration des adresses des sondes DS18B20 pour la 1-Wire temp   *
 *********************************************************************/

// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
 
DeviceAddress sonde1 = { 0x28, 0xFF, 0xBF, 0x72, 0xA4, 0x15, 0x03, 0x5E };// cave
DeviceAddress sonde2 = { 0x28, 0xFF, 0x1E, 0x1B, 0x69, 0x14, 0x04, 0xA7}; // Condenseur sonde de 2 M sur condenseur ou dans gaine d'entrée d'air extérieur.
DeviceAddress sonde3 = { 0x28, 0xFF, 0xB0, 0x14, 0xA5, 0x15, 0x01, 0xBF };// Grenier sonde d'1M.
//DeviceAddress sonde3B = { 0x28, 0xFF, 0x8D, 0x16, 0x64, 0x14, 0x03, 0x50}; //Grenier sonde de 2M.
DeviceAddress sonde4 = { 0x28, 0x31, 0xC9, 0x7B, 0x07, 0x00, 0x00, 0x53 };// Caisson
//DeviceAddress sonde5 = { 0x28, 0xC1, 0xB8, 0x7B, 0x07, 0x00, 0x00, 0x81 };//
//deviceAddress sonde6 = { 0x28, 0x9D, 0x3B, 0x7C, 0x07, 0x00, 0x00, 0xD1 };//
//DeviceAddress sonde7 = { 0x28, 0x62, 0x05, 0x7C, 0x07, 0x00, 0x00, 0xA1 };// 

void setup () {
 
 /**************************
 * Déclaration des sorties*
 **************************/
  pinMode(Relaisclimatisation, OUTPUT);
  digitalWrite(Relaisclimatisation, LOW);//On force le relais de la climatisation au repos. (actif à UN) sur la platine JeeNodePoPHaut.
   pinMode(sortitesimpulsion, OUTPUT);
  digitalWrite(sortitesimpulsion, LOW);
/********************************
/* OUVERTURE DU PORT SERIE COM3 *
/********************************/
 // start serial port
  Serial.begin(115200);

}
 
void printTemperature(DeviceAddress deviceAddress)
{

// set the resolution to 11 bit (good enough?)
  sensors.setResolution(sonde1, 11);
  sensors.setResolution(sonde2, 11);
  sensors.setResolution(sonde3, 11);
  sensors.setResolution(sonde4, 11);
 // sensors.setResolution(sonde5, 11);
 // sensors.setResolution(sonde6, 11);
 // sensors.setResolution(sonde7, 11);

 float tempC = sensors.getTempC(deviceAddress);
  if (tempC == -127.00)
  {
    Serial.print("Error getting temperature");
  }
  else
  {
    valdigit = (tempC * coefficient);
    TempS = (tempC);
   Serial.print(tempC,1); // n'affiche qu'un chiffre derrière la virgule
   Serial.print(" C    ");
   
  }
 

   
 void loop()
  {
 
 /***********************
  * Gestion des Relais  *
 ************************/

 /*****************
 *  Climatisation *
 ******************/
 if   (valdigit1 < 414)
      {(Reponse = 1);}
       // rep:A -- 414-->23° interdit  la clim en dessous de 13.0°C. (225-->12.5°C)
             
      if   (valdigit1 > 414 && valdigit3 < 540)
      {(Reponse = 2);}
       // rep:A -- 414-->23° autorise  la clim au dessus de 13.0°C. (225-->12.5°C)
       // rep:C -- 540-->30° et si la toiture est en dessous de 37°C.(666-->37°C)
     
      if   (valdigit3 < 504)
          {(Defaut = 0);}
           //  rep:B -- 504-->28° retabli la clim en dessous de 34°C. (612-->34°C)
     
      if   (valdigit3 > 540)
      //  rep:C -- 540-->30° coupe la clim au dessus de 37°C.666-->37°C)
     {(Reponse = 3);
      (Defaut = 1);}
 
 
switch (Reponse)
  {
    case 1 :
      digitalWrite(Relaisclimatisation, LOW );//
      Etatrelaisclimatisation = 0;
      break;
   
    case 2 :
      if (Defaut == 0){
     digitalWrite(Relaisclimatisation, HIGH );//
     Etatrelaisclimatisation = 1;
     }
     break; 
           
    case 3 :
   
     digitalWrite(Relaisclimatisation, LOW );//
     Etatrelaisclimatisation = 0;
     break;
 
  }
 
/********************************************************
 *test impulsion de mesure sortie sur 5 borne 11        *
 ********************************************************/
  Clignotant = (millis() / 1000%2);
   if (Clignotant == 1)
   { digitalWrite(sortitesimpulsion, HIGH);
   }
   else
   { digitalWrite(sortitesimpulsion, LOW);
   }
   

/********************************************************
 * traitements et Affichage  des Températures sur COM3  *
 ********************************************************/
 

 Topmesure = (millis()/1000%60);
 Topmesure1=Topmesure;
 switch (Topmesure)
  {
  case 0:
      if (Mesure1 == 0) {
   sensors.requestTemperatures();
 delay(200);
// TX = sensors.getTempC(TempX);
   printTemperature(sonde1);
 delay(50);
  valdigit1 = valdigit;
  TempS1 = TempS;
  Serial.print("temperature sonde N1 CAVE est: ");
  Serial.print("    ");
  Serial.print(TempS1);
  Serial.print("    ");
  Serial.print(" valdigit1 ");
  Serial.print(valdigit1);
  Serial.print("    ");
  Serial.print("\n\r");
       Mesure1 = 1;
       Mesure4 = 0;
    }
   break;
 
 case 15:
    if (Mesure2 == 0) {
   sensors.requestTemperatures();
 delay(200);
   printTemperature(sonde2);
    delay(50);
  valdigit2 = valdigit;
  TempS2 = TempS;
  Serial.print("temperature sonde N2 TOITURE est: ");
  Serial.print("    ");
  Serial.print(TempS2);
  Serial.print("    ");
  //valdigit2 =(valdigit2*(-1)); //pour tester les T° négative
  Serial.print(" valdigit2 ");
  Serial.print(valdigit2);
  Serial.print("\n\r");
       Mesure2 = 1;
       Mesure1 = 0;
      }
  break;
 
  case 30:
    if (Mesure3 == 0) {
   sensors.requestTemperatures();
 delay(200);
   printTemperature(sonde4);
    delay(50);
  valdigit4 = valdigit;
  TempS4 = TempS;
  Serial.print("temperature sonde N4 caisson  est: ");
  Serial.print("    ");
  Serial.print(TempS4);
  Serial.print("    ");
  Serial.print(" valdigit4 ");
  Serial.print(valdigit4);
  Serial.print("\n\r");
      Mesure3 = 1;
      Mesure2 = 0;
    }
   break;
 
  case 45:
      if (Mesure4 == 0){
    sensors.requestTemperatures();
 delay(20);
   printTemperature(sonde3);
    delay(50);
  valdigit3 = valdigit;
  TempS3 = TempS;
  Serial.print("temperature sonde N3 GRENIER  est: ");
  Serial.print("    ");
  Serial.print(TempS3);
  Serial.print("    ");
  //valdigit3 =(valdigit3*(-1)); //pour tester les T° négative
  Serial.print(" valdigit3 ");
  Serial.print(valdigit3);
  Serial.print("    ");
  Serial.print("Etat du relais de la climatisation:");
  Serial.print (Etatrelaisclimatisation);
  Serial.print("\n\r");
  Serial.print ("reponse  ");
  Serial.print (Reponse);
  Serial.print("\n\r");
       Mesure4 = 1;
       Mesure3 = 0;
      }
  break;
  }
     
   
 }

Artouste

...
J'utilise des DS18B20 et la température lue chaque minute n'est pas très stable. Lorsque elle varie de 2 ou 3/10ème
...  mais sur un des Capteur j'ai parfois plus d'un degré d'écart.

bonsoir
les DS18B20 ont une précision de +/- 0.5° au mieux
la résolution elle peut etre de 0.0625 °C
Entre deux capteurs très dispersifs mais "dans les clous" , ça reste dans les specifs 8)

AIRPOPCIE

Bonjour, j'ai repris mon projet et les choses ont BEAUCOUP avancées.

Aujourd'hui je travaille en demandant d'abord " sensors.requestTemperatures();" puis 5 secondes plus tard : TempE = sensors.getTempC(&Capteur1[0]); et avec 1 seconde d'intervalle par DB18B20

ainsi je laisse à chaque sonde le temps de lire puis de me donner la valeur de T°.

Comme les DB18B20 n'ont pas une précision extraordinaire le "digit" bouge dans un délai moyen de 30 à 45 secondes... Et cela est gênant au moment ou l'on arrive au seuil de changement d'état ( relais de radiateur ou clim) même si j'ai mis des valeurs d'hystérésis.

L'idée que j'ai serait d'enregistrer dans un tableau les 50 ou 100 valeurs de TempC, d'en faire la moyenne et prendre ce résultat comme valeur.

J'ai bien trouvé un exemple de création de tableau, écrire dans chaque case, faire la moyenne, mais je n'ai pas trouvé comment décaler vers le haut les valeurs enregistrées pour écrire la nouvelle dans la dernière ligne ...

Sinon que de lire la valeur de la deuxième  ligne pour l'écrire dans la première, puis lire la troisième et l'écrire dans la deuxième ETC...

Mais existe t il une librairie ou programme tout fait pour réaliser ce décalage?...

Merci de votre aide

dfgh

hello
j'ai fais ce code pour un niveau de cuve dans mon jardin
il fait 50 mesures, les classe en ordre croissant
et fait la moyenne des températures de la case 10 à la case 30

Code: [Select]

long distances[51];

void lecture_niveau_cuves() {
  for (int f = 1; f <= 50; f++) {
    distances[f] = ultrasonic.distanceRead();
    delay(100);
  }
  for (byte g = 1; g <= 49; g++) {
    for (byte f = 1; f <= 49; f++) {
      if (distances[f] > distances[f + 1]) {
        distances[51] = distances[f + 1];
        distances[f + 1] = distances[f];
        distances[f] = distances[51];
      }
    }
  }
  for (byte f = 1; f <= 50; f++) {
    Serial.print(distances[f]);
    Serial.print("_");
  }
  distances[51] = 0; Serial.println(" ");
  for (byte f = 11; f <= 40; f++) {
    distance += distances[f];
    Serial.print(distance);
    Serial.print("_");
  } Serial.println(" ");
  distance = distance / 30;
  Serial.println(distance);


à toi d'adapter

bilbo83

Bonjour,

Attention dfgh, distances[51] n'existe pas.

En C/C++, un tableau à N éléments sont notés de 0 à N-1.

Cela peut provoquer des erreurs ou même des plantages lorsque le programme veut accéder à une case mémoire qui n'a pas été réservée correctement.

AIRPOPCIE

normalement il faut pour un tableau de 50 prendre 0 comme 1ere Ligne et 49 pour la derniere..
Alors je dois déclarer long releveTC[50];

gfgh tu as écris ce programme pour un arduino?..
Merci de ton aide.
Merci bibo83 pour ta remarque.
A suivre..A+

dfgh

hello vous deux
oui, je suis béni des dieux, car le prg ne plante pas et pourtant, il le devrait.... je corrige immédiatement.
oui, le prg tourne sur une méga

destroyedlolo

Salut,

le prg ne plante pas et pourtant, il le devrait....
Non, il n'y a pas de raison : tu ne fais qu'accédé à une mémoire qui ne t'appartient pas et donc comme il n'y a pas de MMU, le programme ne fait que te renvoyer la valeurs qui s'y trouve.
Bref, t'as un problème conceptuel mais rien qui ne peux provoquer de plantage.

Maintenant, je ne comprend pas vraiment ton pb : j'ai une 20e de DS18b20 dans ma maison, mais je n'ai jamais eu ce genre de fluctuations, parfois quelques 100e de degré mais jamais plus.
Par contre, mes sondes sont alimentées en 5V ... et 5V stables.
Les seuls fois ou j'ai eu des valeurs aberrantes, c'était a cause d'une alim foireuse.

A+

AIRPOPCIE

bonjour destroyedlol comme je l'ai écris plus haut depuis que j'ai modifié ma façon d'appeler les sondes puis de lire le résultat 750ms plus tard c'est bien stable...Mais il y a un mais:
une de mes sondes (pas sur la même entrée que les DS18B20) est un DHT22 TRES STABLE en mesure de T° mais très fluctuante en mesure d'hygrométrie.
C'est pourquoi je voudrais "moyenner" sur 50 ou 100 mesures.

Je travaille actuellement pour faire un tableau et en faire la moyenne.
Juste pour le fun peux tu me mettre ton croquis d'acquisition de tes DS18B20?.
Merci
 

destroyedlolo

#11
Jul 24, 2018, 05:55 pm Last Edit: Jul 24, 2018, 06:00 pm by destroyedlolo
Juste pour le fun peux tu me mettre ton croquis d'acquisition de tes DS18B20?
J'ai mieux : j'ai fait un tuto sur mon site la dessus.
A noter que je n'utilise plus la classique DallasTempérature mais une librairie maison OWBus qui a l'avantage de prendre en charge d'autres chips 1-wire.

Les 20 sondes dont je parlais ne sont pas gérées sur Arduino mais sous Linux avec l'indispensable OWFS. Sur mes ESP, je n'ai pas plus de 2 sondes pour le moments, non pas qu'il y ait une limitation quelconque, mais j'utilise les ESP pour des sondes déportées et il n'y a pas besoin de plus :)

manumanu

Bonjour;
J'accroche au sujet;

Il existe deux façons de brancher les DS18B20. En mode classique ou en mode "parasite". Voire le DATASHEET.
Comment à tu branché tes sondes? Quel type de cable utilise tu et sont il blindé et passe t'il a proximité d'autres câbles de réseau d'alimentations de "puissance" ?

Pour ce qui est de la moyenne ! Permettez moi une suggestion !!?

Étant donné que tu effectue X mesures utiles pour le calcule de ta moyenne...
Que -finalement - chaque valeurs de mesures chargées serra additionné à la précédente...
Pourquoi ne pas simplement les additionner à chaque relevés puis exécuter une division une fois le nombre X de mesure relevés.

Ce qui reviens en somme à effectuer l'addition et un comptage des relevés pour ensuite traiter la moyenne par calcul.
Plutôt que de les charger dans un tableau -qui occupera de l'espace mémoire- et demandera un phase de traitement supplémentaire.

Perso: L'utilisation d'un tableau est plutôt utile pour le traitement de donnée distinctes.

Salutations. 
"Apprends moi ce que tu sais je t'apprendrais ce que je sais en nous serons intelligent"

AIRPOPCIE

Bonjour merci manumanu de t'intéresser au sujet.

Les sondes utilisées sont:
- DHT22 pour T° et HR dans la cave. C'est cette dernière qui est varie assez vite.
-DB18B20 en waterproof longueur 1 ou 2m
( le volume dans lequel je fais 4 mesures est de l'ordre de 2m3 caisson renfermant la clim 2 sondes
1 sonde T° grenier à l'extérieur du caisson
T° Air-Admise à l'entrée de la prise d'air sur le toit à 1m au dessus).

Comme je l'ai expliqué plus haut le fait d'avoir modifié la saisie des T° rend stable les T°.

Le principe de mesure D18B20:

1). d'abord une demande de mesure:
void DemarrerConversionTemperatures() {
digitalWrite(SortieDebug, HIGH);
sensors.setWaitForConversion(false);
sensors.requestTemperatures();
sensors.setWaitForConversion(true);
digitalWrite(SortieDebug, LOW);
TacheDemarrerLesSondesFaite = true;
}

2). Ensuite une lecture:
void LectureDesTemperatures() { // Lecture des capteurs I2C successivement
TempE = sensors.getTempC(&Capteur1[0]);
TempK = sensors.getTempC(&Capteur2[0]);
TempG = sensors.getTempC(&Capteur3[0]);
TempR = sensors.getTempC(&Capteur4[0]);

entre les 2 appels: 750 mS pour laisser au DB18B20 le temps de travailler.

Je suis entrain de créer un tableau et d'y enregistrer les HR 30 mesures) pour ensuite en faire la moyenne.

Voilà.. Merci de vous intéresser à ce sujet.
Salutaions.

AIRPOPCIE

bonjour ca y est c'est au point.

1) je lis la valeur de TH (hygrométrie);
2) Je rempli le tableau de 20 lignes avec cette valeur.
3) Je lis la valeur que je viens écrire dans la 1ere ligne du tableau
4) Je fais la somme.
5) Je fais la moyenne.

Arrivé à la ligne 20 du tableau je retourne à la 1ere.

Ca fonctionne très bien je lisse au 1/eme à chaque seconde vu que je fais une lecture par seconde.
Mais on peux afficher la moyenne que toutes les 20 secondes voir plus.
Ci joint le croquis.
Code: [Select]


/*******************************************************************
 *  Calcul d'une moyenne sur 20 lectures à raison d'une  par seconde                     *
 *        Par AIRPOPCIE             Juillet 2018                                                           *
 *******************************************************************/


#include <Arduino.h>
#include <DHT.h>                                      // Librairie des capteurs DHT                   
#define DHTTYPE DHT22                             // DHT 22  (AM2302)
#define DHTPIN 9                                       // pin sur lequel est branché le DHT
DHT dht(DHTPIN, DHTTYPE);
const int  GrandeurDuTableau = 20;            // Nombre de lignes du tableau
double TableauHR[GrandeurDuTableau];      // Notre tableau
int IndexDuTableau                = 0;              // On initialise le pointeur
int IndexDecriture                  = 0;              // Pour écrire chaque valeur lue
double TotalDesMesures         = 0;              // Pour totaliser les valeurs enregistrées pour en faire la moyenne
double MoyenneDesHR           = 0;             // Comme son nom l'indique
float TH                                 = 00.           // Hygrométrie lue dans DHT22
float TDHT                             = 00.0;
float THLU                             = 00.00;

 void setup() {
 dht.begin();
 Serial.begin(115200);
   LireDHT22();
    delay (1000);
 // On initialise le tableau avec la valeur lue de TH
 for (byte CT = 0; CT<(GrandeurDuTableau);CT++){
   TableauHR[CT] = THLU;
   //Serial.print("CT:");Serial.println(CT);
 //  Serial.print("THLU:");Serial.println(THLU);
 //delay (100);
 }
}

void LireDHT22() { //Lecture du taux d'humidité
        float TH = dht.readHumidity();
        // Lecture de la température en Celcius
        float TDHT = dht.readTemperature();
        // Pour lire la température en Fahrenheit
        float f = dht.readTemperature(true);
        THLU = TH;
        Serial.print("valeur lue:");Serial.println(THLU);
       //Stop le programme et renvoie un message d'erreur si le capteur ne renvoie aucune mesure
       if (isnan(TH) || isnan(TDHT) || isnan(f)) {
       Serial.println("Echec de lecture !");
       return;
       }
        delay (500);  
}

void Additionner(){
for (IndexDuTableau = 0;IndexDuTableau<=(GrandeurDuTableau-1);IndexDuTableau++){
  TotalDesMesures = (TotalDesMesures +TableauHR[IndexDuTableau]);
  // Serial.print("Valeur enregistrée:");Serial.println(TableauHR[IndexDuTableau]);
  // Serial.print("IndexDuTableau:");Serial.println(IndexDuTableau);
 //  Serial.print("TotalDesMesures:");Serial.println(TotalDesMesures);
  
  // delay (250);
 }  
}
void Moyenner() {
MoyenneDesHR = ( TotalDesMesures /GrandeurDuTableau);
TotalDesMesures = 0;
Serial.print("MoyenneDesHR :");Serial.println(MoyenneDesHR );
}  

void StockerNouvelleValeur(){
  if(IndexDecriture<(GrandeurDuTableau)){
  TableauHR[IndexDecriture] = THLU;}
  //Serial.print("IndexDecriture :");Serial.println(IndexDecriture);
  IndexDecriture = IndexDecriture +1;
  
if(IndexDecriture==(GrandeurDuTableau-1)){
  IndexDecriture = 0;
   }

  }


void loop() {
 LireDHT22();
 StockerNouvelleValeur();
 Additionner();
 Moyenner();
 delay (1000);
 }

Go Up