aide sur projet boitier multifonctions astronomie

Matériel:
-Arduino mini pro 328 5v
-24LC256 eeprom x2. Extension mémoire arduino mini pro.
-DHT22 calcule du point de rosée, pour le déclenchement de l'alimentation électrique, des résistance chauffante.
-DS18B20 surveillance de la température du boitier multifonction.
-ACS712 calcule de la consommation électrique (connaitre l'autonomie de la batterie vl).
-5 pont diviseur fonction voltmètre.

Savoir ci mon code est juste.

Difficulté de terminer la partie point de rosée pour le déclenchement du relais.
Ainsi, que la partie Temp boitier manque affichage "danger" suivant une tempèrature elevée de celui-ci ex 80°

ci-joint les onglets du menu de commande

onglet: tuto_menue_liste

 /*--------------------------------------------------------------
   EEPROM 24lc256 id ci. u3
   EEPROM 24lc256 id ci. u2
   Arduino Analog pin 4 - SDA - EEPROM pin 5
   Arduino Analog pin 5 - SCL - EEPROM pin 6
   Arduino 5V           - VCC - EEPROM pin 8
   Arduino GND          - VSS - EEPROM pin 4
   
   A0 Bouton de commande BP_NONE,BP_UP,BP_DOWN,BP_LEFT,BP_SELECT
   diviseurs de tension sur A1,A2,A3,A6. &(PIN 10 pour la conso électrique *)
   A7 ACS712 Conso Electrique *
   Pin3 ds18b20 tempèrature boitier
   Pin2 DTH22 Capteur point de rosée
   Relais Pin 13
   
   Matériel: Arduino PRO MINI
                 4 x 16 LCD relié aux broches standards utilisés dans  
                 Eprom 24lc256 x2
                 Relais 5v
                 DTH22
                 DS18B20
                 Pont diviseurs x5
                 
   Logiciel: Développé en utilisant le logiciel Arduino 1.6.5 
            

   Date: 26/10/2015
--------------------------------------------------------------*/

#include <Wire.h>  
#include <LiquidCrystal.h> /* Inclut la librairie LiquidCrystal pour le LCD */
#include "Menu.h" // Fichier d'entête avec les types pour le menu
#include "Wire.h"
#include <OneWire.h>
#include <DHT22.h>
#include <SPI.h>
#include <stdio.h>

#define disk1 0x50    //Address of 24LC256 eeprom chip 
/* Objet LCD sur les broches utilisées par la shield LCD DFrobots */
static LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
/* Menu principal */
static const char* MAIN_MENU_ITEMS[] = {
  "Voltmetre",
  "Conso Elec",
  "Point de rosee",
  "Temp Boitier",
  
};
static const Menu_t MAIN_MENU = {
  "Votre choix ?",
  MAIN_MENU_ITEMS,
  4,
};

/** Setup */
void setup() {
 {
   {
 //Message de bienvenue
 lcd.setCursor(0,1); //En haut à gauche (numéroté depuis 0)
 lcd.print("Alim Astro"); // Afficher un petit message
 lcd.setCursor(0,2);   //2emme Ligne
 lcd.print("Mogenot D. V3");   // Afficher un petit message
 
 delay(5000);  //intro de 5 secondes-
 
 lcd.setCursor(0,1);   //Ligne du bas
 lcd.print("               ");   //Effacer cette ligne
 lcd.setCursor(0,0);            
 lcd.print("Choisir 1 bouton"); // Afficher un petit message
}
  Serial.begin(57600);  
  /* Configuration du LCD */
  lcd.begin(16, 4);
}
  /* Configuration EEPROM */
Wire.begin();    
 
  unsigned int address = 0;
 
  writeEEPROM(disk1, address, 123);
  Serial.print(readEEPROM(disk1, address), DEC);
  }
 
/** Programme principal */
void loop() {
 EEPROM();
 Voltmetre();
 ConsoElec();
 TempBoitier();
 PointDeRosee();
 /* Affiche le menu principal */
  displayMenu(MAIN_MENU);
 
  /* Démo pour montrer la sortie du menu */
  lcd.clear();
  lcd.print(F("Menu ferme"));
  delay(2000);
}
 
/** Fonction retournant le bouton appuyé (s’il y en a un). */
Button_t readPushButton(void) {
 
  /* Lecture de l'entrée A0 */
  unsigned int val = analogRead(A0);
 
  /* Test suivant les fourchettes de valeurs */
  if (val > 1000) return BP_NONE;
  if (val < 50) return BP_RIGTH;  
  if (val < 195) return BP_UP; 
  if (val < 380) return BP_DOWN; 
  if (val < 555) return BP_LEFT; 
  if (val < 790) return BP_SELECT;
 
  /* Par défaut aucun bouton n'est appuyé */
  return BP_NONE;
}
 
/** Affiche le menu passé en argument */
void displayMenu(const Menu_t &menu) {
 
  /* Variable pour le menu */
  byte selectedMenuItem = 0;   // Choix selectionné
  byte shouldExitMenu = false; // Devient true quand l'utilisateur veut quitter le menu
  Button_t buttonPressed;      // Contient le bouton appuyé
 
  /* Tant que l'utilisateur ne veut pas quitter pas le menu */
  while(!shouldExitMenu) {
 
    /* Affiche le menu */
    lcd.clear();
    lcd.print(menu.prompt);
    lcd.setCursor(0, 1);
    lcd.print(menu.items[selectedMenuItem]);
 
    /* Attend le relâchement du bouton */
    while(readPushButton() != BP_NONE);
 
    /* Attend l'appui sur un bouton */
    while((buttonPressed = readPushButton()) == BP_NONE);
 
    /* Anti rebond pour le bouton */
    delay(30);
 
    /* Attend le relâchement du bouton */
    while(readPushButton() != BP_NONE);
 
    /* Gére l'appui sur le bouton */
    switch(buttonPressed) {
    case BP_UP: // Bouton haut = choix précédent
 
      /* Si il existe un choix précédent */
      if(selectedMenuItem > 0) {
 
        /* Passe au choix précédent */
        selectedMenuItem--;
      }
      break;
 
    case BP_DOWN: // Bouton bas = choix suivant
 
      /* Si il existe un choix suivant */
      if(selectedMenuItem < (menu.nbItems - 1)) {
 
        /* Passe au choix suivant */
        selectedMenuItem++;
      }
      break;
 
    case BP_LEFT: // Bouton gauche = sorti du menu
      shouldExitMenu = true;
      break;
 
    case BP_SELECT: //
    case BP_RIGTH:  // Bouton droit ou SELECT = validation du choix
      menu.callbackFnct(selectedMenuItem);
      break;
    }
  }
}
 
/** Affiche le choix de l'utilisateur */
void doMainMenuAction(byte selectedMenuItem)
  
{
    /* Affiche le choix de l'utilisateur */
    displayChoice(selectedMenuItem, MAIN_MENU_ITEMS);
  }
 
/** Affiche le choix de l'utilisateur */
void displayChoice(byte selectedMenuItem, const char** items) {
 
  /* Affiche le choix de l'utilisateur */
  lcd.clear();
  lcd.print(F("valider :"));
  lcd.setCursor(0, 1);
  lcd.print(items[selectedMenuItem]);
 
  /* Attend l'appui sur le bouton gauche ou SELECT */
  byte buttonPressed;
  do {
    buttonPressed = readPushButton();
  } 
  while(buttonPressed != BP_LEFT && buttonPressed != BP_SELECT);
}

onglet: menu.h

#ifndef _MENU_H_
#define _MENU_H_
 
/* Structure d'un menu */
typedef struct {
  const char* prompt;     // Titre du menu
  const char** items;     // Tableau de choix du menu
  const uint8_t nbItems;  // Nombre de choix possibles
  void (*callbackFnct)(uint8_t menuItemSelected); // Pointeur sur fonction pour gérer le choix de l'utilisateur
} Menu_t;
 
/* Listes des touches de la shield lcd DFrobots */
typedef enum {
  BP_NONE,   // Aucun bouton appuyé
  BP_SELECT, // Bouton SELECT
  BP_LEFT,   // Bouton gauche
  BP_RIGTH,  // Bouton droite
  BP_UP,     // Bouton haut
  BP_DOWN    // Bouton bas
} Button_t;
 
#endif /* _MENU_H_ */

onglet: eeprom

#include <Wire.h>    
 
void EEPROM(){}
 
void writeEEPROM(int deviceaddress, unsigned int eeaddress, byte data ) 
{
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.write(data);
  Wire.endTransmission();
 
  delay(5);
}
 
byte readEEPROM(int deviceaddress, unsigned int eeaddress ) 
{
  byte rdata = 0xFF;
 
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
 
  Wire.requestFrom(deviceaddress,1);
 
  if (Wire.available()) rdata = Wire.read();
 
  return rdata;
}

onglet: point de rosee

 /*------------------------------------------------------------------------
Programe:      Mesure de la température et l'humidité de l'air avec le DTH22.
               Calcule du point de rosée, pour l'alimentation du régulateur de 
               résistance chaufante.
               (formation de buée par condensation sur les miroirs).

Description: déclanchement du relais si le point de rosée est égal à la temp.
             
Raccordements: DTH22 sur pin 2. Relais sur pin 13.
  
  Date: 26/10/2015
 --------------------------------------------------------------------------*/

#include <DHT22.h>
#include "Wire.h"
#include <SPI.h>

// Only used for sprintf
#include <stdio.h>

int Pel = 13;// sortie relai
 
// Data wire is plugged into port 2 on the Arduino
// Connect a 4.7K resistor between VCC and the data pin (strong pullup)
#define DHT22_PIN 2

// Setup a DHT22 instance
DHT22 myDHT22(DHT22_PIN);

void PointDeRosee(void)
{ 
  DHT22_ERROR_t errorCode;
  
  // The sensor can only be read from every 1-2s, and requires a minimum
  // 2s warm-up after power-on.
  delay(2000);
  
  Serial.print("Requesting data...");
  errorCode = myDHT22.readData();
  switch(errorCode)
  {
    case DHT_ERROR_NONE:
      Serial.print("Got Data ");
      Serial.print(myDHT22.getTemperatureC());
      Serial.print("C ");
      Serial.print(myDHT22.getHumidity());
      Serial.println("%");
      // Alternately, with integer formatting which is clumsier but more compact to store and
    // can be compared reliably for equality:
    //    
      char buf[128];
      sprintf(buf, "Integer-only reading: Temperature %hi.%01hi C, Humidity %i.%01i %% RH",
                   myDHT22.getTemperatureCInt()/10, abs(myDHT22.getTemperatureCInt()%10),
                   myDHT22.getHumidityInt()/10, myDHT22.getHumidityInt()%10);
      Serial.println(buf);
      break;
    case DHT_ERROR_CHECKSUM:
      Serial.print("check sum error ");
      Serial.print(myDHT22.getTemperatureC());
      Serial.print("C ");
      Serial.print(myDHT22.getHumidity());
      Serial.println("%");
      break;
    case DHT_BUS_HUNG:
      Serial.println("BUS Hung ");
      break;
    case DHT_ERROR_NOT_PRESENT:
      Serial.println("Not Present ");
      break;
    case DHT_ERROR_ACK_TOO_LONG:
      Serial.println("ACK time out ");
      break;
    case DHT_ERROR_SYNC_TIMEOUT:
      Serial.println("Sync Timeout ");
      break;
    case DHT_ERROR_DATA_TIMEOUT:
      Serial.println("Data Timeout ");
      break;
    case DHT_ERROR_TOOQUICK:
      Serial.println("Polled to quick ");
      break;
  }
  //Serial.print("DPF = ");  //Dew PointFast
  //Serial.print(dewPointFast(DHT22.temperature, DHT22.humidity));
  //Serial.print (" C "); 
  //Serial.print("\n"); //A la ligne
  delay(500);  //0.5 sec de délai de rafraichissement
}
  // Point de rosée (dewPoint) function NOAA
// reference: http://wahiduddin.net/calc/density_algorithms.htm 
double dewPoint(double celsius, double humidity)
{
   double A0= 373.15/(273.15 + celsius);
   double SUM = -7.90298 * (A0-1);
   SUM += 5.02808 * log10(A0);
   SUM += -1.3816e-7 * (pow(10, (11.344*(1-1/A0)))-1) ;
   SUM += 8.1328e-3 * (pow(10,(-3.49149*(A0-1)))-1) ;
   SUM += log10(1013.246);
   double VP = pow(10, SUM-3) * humidity;
   double T = log(VP/0.61078);   // temp var
   return (241.88 * T) / (17.558-T);
}

// delta max = 0.6544 wrt dewPoint()
// 5x faster than dewPoint()
// reference: http://en.wikipedia.org/wiki/Dew_point
double dewPointFast(double celsius, double humidity)
{
   double a = 17.271;
   double b = 237.7;
   double temp = (a * celsius) / (b + celsius) + log(humidity/100);
   double Td = (b * temp) / (a - temp);
   return Td;
}

onglet: Conso_Elect

 /*------------------------------------------------------------------------
Programe:       Consommation électrique "boitier alimentation ASTRO"

Description: Calcule de la consommation électrique.
            
Raccordements: ACS712 Pin Raccordements A7            
               Pont diviseur de tension Pin10 (id ci R11 10 Kohms, R16 1 Mohms)
  
  Date: 26/10/2015
 --------------------------------------------------------------------------*/

int batMonPin = 10;    // Broche d'entrée pour le diviseur de tension
int batVal = 0;       // variable poiur la valeur A/D
float pinVoltage = 0; // Variable pour contenir la tension calculée 
float batteryVoltage = 0;

int analogInPin = A7;  // Broche d'entrée analogique du capteur ACS712
int sensorValue = 0;        // valeur lue
int outputValue = 0;        // sortie en milliampères
unsigned long msec = 0;
float time = 0.0;
int sample = 0;
float totalCharge = 0.0;
float averageAmps = 0.0;
float ampSeconds = 0.0;
float ampHours = 0.0;
float wattHours = 0.0;
float amps = 0.0;

int R11 = 100; // Résistance en Kohms R11
int R16 = 1; // Résistance en Mohms R16
float ratio = 0;  // Calculated from R11 / R16


void ConsoElec()   // Fonction principale
{
 
int sampleBVal = 0;
int avgBVal = 0; 
int sampleAmpVal = 0;
int avgSAV = 0;
 
for (int x = 0; x < 10; x++){ // En boucle 10x

  // lit la valeur analogique:
  sensorValue = analogRead(analogInPin);  
  sampleAmpVal = sampleAmpVal + sensorValue; // ajouter échantillons

  batVal = analogRead(batMonPin);    // lit la tension sur le diviseur
  sampleBVal = sampleBVal + batVal; // ajouter échantillons 
 
  delay (10); // 
}

avgSAV = sampleAmpVal / 10;

  // convert to milli amps
  outputValue = (((long)avgSAV * 5000 / 1024) - 500 ) * 1000 / 133; 
 
/* 
le capteur délivre environ 100 au repos.
Analog it une valeur de 0-1023, ce qui équivaut à 0V à 5V.
(((long) sensorValue * 5000/1024 ) est la tension sur la sortie du capteur en millivolts.
Il ya un décalage de soustraire 500mV .
L'unité produit 133mv par ampère de courant.
diviser par 0,133 pour convertir mv pour ma
*/

avgBVal = sampleBVal / 10; //divide by 10 (number of samples) to get a steady reading

  pinVoltage = avgBVal * 0.00610;       //  Calculate the voltage on the A/D pin
                                /*  Une lecture de 1 pour l' A / D = 0.0048mV
                                    si l'on multiplie la lecture A / D puis par 0,00488
                                    on obtient la tension sur la broche .
                                    NOTE! 0,00488 est idéal.
*/

  ratio = (float)R11 / (float)R16;
  batteryVoltage = pinVoltage * ratio;    //  Utiliser le rapport calculé pour le diviseur de tension
                                          //  pour calculer la tension de la batterie
                                         
                                           
  amps = (float) outputValue / 1000;
  float watts = amps * batteryVoltage;
   
  Serial.print("Volts = " );                      
  Serial.print(batteryVoltage);     
  Serial.print("\t Current (amps) = ");     
  Serial.print(amps); 
  Serial.print("\t Power (Watts) = ");  
  Serial.print(watts);  
 
   
  sample = sample + 1;
 
  msec = millis();
 
  time = (float) msec / 1000.0;
 
  totalCharge = totalCharge + amps;
 
  averageAmps = totalCharge / sample;
  ampSeconds = averageAmps*time;
  
  ampHours = ampSeconds/3600;
 
  wattHours = batteryVoltage * ampHours;
 
  Serial.print("\t Time (hours) = ");
  Serial.print(time/3600);
 
  Serial.print("\t Amp Hours (ah) = ");
  Serial.print(ampHours);
  Serial.print("\t Watt Hours (wh) = ");
  Serial.println(wattHours);
  
    lcd.setCursor(0,0);
    lcd.print(batteryVoltage);
    lcd.print(" V ");
    lcd.print(amps);
    lcd.print(" A ");
 
  lcd.setCursor(0,1);
  lcd.print(watts);
  lcd.print(" W ");
  lcd.print(time/3600);
  lcd.print(" H ");
 
  lcd.setCursor(0,2);
  lcd.print(ampHours);
  lcd.print(" Ah ");
  lcd.print(wattHours);
  lcd.print(" Wh ");
 
  lcd.setCursor(0,3);
  lcd.print(ratio, 5);
  lcd.print("   ");
  lcd.print(avgBVal);
 
  // attendre 10 millisecondes avant la boucle suivante
  // pour le convertisseur analogique-numérique pour régler
  // après la dernière lecture :
  delay(10);                    
}

onglet: Temp_boitier

 /*------------------------------------------------------------------------
Programe:      Température boitier alimentation astro.

Description: Affichage de la température du boitier ci température max atteint, 
             affichage DANGER.
  
Raccordements: Sondes broche DS18B20 Pin 3
  
   Date: 27/10/2015
  température du boitier
 --------------------------------------------------------------------------*/

#include <OneWire.h> // librairie pour capteur OneWire

// --- Déclaration des constantes ---
//---- code des instructions du capteur
const int modeLecture=0xBE;
const int lancerMesure=0x44;
const int broche_OneWire=3; //declaration constante de broche 

// --- Déclaration des variables globales ---
byte data[12];
byte adresse[8]; 
float ma_tempetf=0.0; 

OneWire  capteur(broche_OneWire);void TempBoitier(){

ma_tempetf=capteurMesureTemp(); // appel de la fonction de mesure - renvoie une valeur float

Serial.print ("Temperature = "); 
Serial.print (ma_tempetf,2); 
Serial.println (" Degres Celsius. "); 

}
void capteurInit(void) // fonction qui ne reçoit rien et ne renvoie rien
{
Serial.println("**** Detection du capteur **** "); 
while (capteur.search(adresse)== false) // tant qu'aucun nouveau capteur est détecté
{
  Serial.println("Aucun capteur 1-wire present sur la broche ! "); // affiche message + saut de ligne
  delay (1000); // pause 1 seconde
}
  Serial.print ("1 capteur 1-wire present avec code adresse 64 bits : ");
   for(int i = 0; i < 8; i++) { // l'adresse renvoyée par la fonction search est stockée sur 8 octets
    if (adresse[i]<16) Serial.print('0'); // pour affichage des O poids fort au format hexadécimal
    Serial.print(adresse[i], HEX); // affiche 1 à 1 les 8 octets du tableau adresse au format hexadécimal
    Serial.print(" ");
  }
  Serial.println(); 
  if (adresse[0]==0x28) 
  { 
    Serial.println ("Type du capteur present : Capteur temperature DS18B20.");
  }
  else
  {
    Serial.println ("Le capteur present n'est pas un capteur de temperature DS18B20.");
  }
  if (capteur.crc8( adresse, 7) == adresse[7]) 
  {
    Serial.println ("Verification du code CRC de l'adresse 64 bits de ce capteur : VALIDE !"); 
  }
  else
  {
    Serial.println ("Verification du code CRC de l'adresse 64 bits de ce capteur : NON VALIDE !");     
  }

  //------- message final détection ---- 
  Serial.println("----- fin de la recherche du capteur ----"); 
  Serial.println("");   
}

float capteurMesureTemp(void) { 
  int tempet=0; 
  float tempetf=0.0; 
  capteur.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
  capteur.select(adresse); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
  capteur.write(lancerMesure,1); // lance la mesure et alimente le capteur par la broche de donnée

delay(1000);     // au moins 750 ms
           
  capteur.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
  capteur.select(adresse); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
  capteur.write(modeLecture,1); // passe en mode lecture de la RAM du capteur

for ( int i = 0; i < 9; i++) {           // 9 octets de RAM stockés dans 9 octets
    data[i] = capteur.read();             // lecture de l'octet de rang i stocké dans tableau data
  }
data[1]=data[1] & B10000111; // met à 0 les bits de signes inutiles
tempet=data[1]; // bits de poids fort
tempet=tempet<<8; 
tempet=tempet+data[0]; // bits de poids faible

tempetf=float(tempet)*6.25;
tempetf=tempetf/100.0;

return (tempetf);

}

onglet: Voltmetre

 /*------------------------------------------------------------------------
Programe:      voltmeter_LCD

Description: 4 canaux voltmètre DC avec des tensions affichées 
             sur l'écran LCD à 1a décimale. 
  
Raccordements: diviseurs de tension sur A1,A2,A3,A6. &(PIN 10)

   Date: 14/07/2014
 --------------------------------------------------------------------------*/
// nombre d'échantillons analogiques à prendre par la lecture, par canal
#define NUM_SAMPLES 10
// valeurs d'étalonnage de diviseur de tension
#define DIV_1    8.785
#define DIV_2    8.785
#define DIV_3    8.785
#define DIV_4    8.785
// Valeur de tension de référence ADC / calibration
#define V_REF    4.95

int sum[4] = {0};                // sommes d'échantillons prélevés
unsigned char sample_count = 0;  // taille de l'échantillon
float voltage[4] = {0.0};        // tensions calculées
char l_cnt = 0;                  // utilisé dans »pour« boucles

void Voltmetre()   // Fonction principale
{
     
  // prendre un certain nombre d'échantillons analogiques et de les additionner
    while (sample_count < NUM_SAMPLES) {
        // sample diviseurs de tension sur A1,A2,A3,A6
        for (l_cnt = 0; l_cnt < 4; l_cnt++) {
            sum[l_cnt] += analogRead(A1 + l_cnt);
        }
        sample_count++;
        delay(10);
    }
    // calculer la tension de chaque canal
    for (l_cnt = 0; l_cnt < 4; l_cnt++) {
        voltage[l_cnt] = ((float)sum[l_cnt] / (float)NUM_SAMPLES * V_REF) / 1024.0;
    }
    // tensions d'affichage sur l'écran LCD
    // chaque tension est multipliée par le réseau de résistances
    // facteur de division pour calculer la tension réelle
   
    // Entête Voltmètre
    lcd.setCursor(3, 0);
    lcd.print("Voltmetre ");
    
    // tension 1 - A (pin A1)
    lcd.setCursor(0, 1);
    lcd.print("A ");
    lcd.print(voltage[0] * DIV_1, 1);
    lcd.print("V ");
    
    // tension 2 - B (pin A2)
    lcd.setCursor(8, 1);
    lcd.print("B ");
    lcd.print(voltage[1] * DIV_2, 1);
    lcd.print("V ");
    
    // tension 3 - C (pin A3)
    lcd.setCursor(0, 2);
    lcd.print("C ");
    lcd.print(voltage[2] * DIV_3, 1);
    lcd.print("V ");
    
    // tension 4 - D (pin A6)
    lcd.setCursor(8, 2);
    lcd.print("D ");
    lcd.print(voltage[3] * DIV_4, 1);
    lcd.print("V ");
    
    // réinitialiser le nombre et les montants
    sample_count = 0;
    for (l_cnt = 0; l_cnt < 4; l_cnt++) {
        sum[l_cnt] = 0;
    }
}

merci pour une aide.

DENISmgt:
Difficulté de terminer la partie point de rosée pour le déclenchement du relais.
Ainsi, que la partie Temp boitier manque affichage "danger" suivant une tempèrature elevée de celui-ci ex 80°

Pour determiner le point de roser il faut utilisé la courbe heinrich

oui merci

Juste il me manque les de code,pour la commande du relais au point de rosée.

Reste à savoir ci tous ça fonctionne.

bonjour,
je vais essayer de retrouver mon code pour le même projet que j’ai déjà utilisé sur le terrain.
le but étant de déclencher la resistance chauffante avant d’atteindre l’équilibre entre la temp et le PR.
il suffit d’avoir une diff de 1-2C pour éviter la buée.

Bonjour,
Alors infobarquee on ne retrouve plus ses posts :slight_smile:
Ils se trouvent ici.
On trouve toujours ce que l'on ne cherche pas :wink:

Merci
pour le moment test eeprom 24LC256 ok
avec I2C-EEPROM

512 bytes

Pour le fonctionnement du relais faut il écrire ceci dans longlet point_de_rosee

int Pel = 13; // pin sortie relais

float getTemperatureC;
float getHumidityInt;

void pointDeRosee(void)

if (getHumidityInt != getTemperatureC){
digitalWrite (Pel,LOW); // Relais ON
}
else
{
digitalWrite (Pel,HIGH); // Relais OFF

a insérer dans le code source

tu peux, mais il faut prendre en compte le temps de chauffe de la résistance et la chauffeur dissipée après coupure, sinon, ca va se mettre en route toutes les secondes :wink:
donc mettre une fourchette de 2-3C serait bien.
j'utilise plus un ventilo pour mettre en sur pression mon par buée qu'une résistance, je trouve que ca perturbe moins l'air surtout pour la photo.

@ Icare
l'age, l'age mon brave, héhéhéhé

infobarquee:
@ Icare
l'age, l'age mon brave, héhéhéhé

:grin:
çà c'est un probleme qui debute à la naissance

comme ceci

pour -3°

if (getHumidityInt != getTemperatureC -3)

le code source precent ne va pas du tout

je reconpile tous ça

par contre il y a une erreur
error: expected unqualified-id before ‘{’ token
Erreur lors de la compilation.

je ne la trouve pas
un coup de main ne sera pas de refus merci

#include <LiquidCrystal.h> //Inclut la librairie LiquidCrystal pour le LCD
#include <DHT22.h> //Inclut la librairie Capteur DHT22
#include <OneWire.h> //Inclut la librairie DallasTemperature DS18B20
#include <Wire.h> //Inclut la librairie eeprom 24LC256
#include “Menu.h”

/** cont type de donnée non constante = valeur **/
const byte RELAY = 13; // Relais connecter sur pin 13
const byte DTH22 = 2; // Capteur DTH22 connecter sur pin 2
const byte DS18B20 = 3; // Capteur DallasTemperature DS18B20 connecter sur pin 3
const byte DIV_1 = A1; //diviseur de tension sur pin A1
const byte DIV_2 = A2; //diviseur de tension sur pin A2
const byte DIV_3 = A3; //diviseur de tension sur pin A3
const byte DIV_4 = A6; //diviseur de tension sur pin A6
const byte DIV_5 = 10; //diviseur de tension sur pin 10

#define disk1 0x50 //Adresse eeprom 24LC256 sur pin A4 & A5
/--------------------------------------------------------------------------/
/valeurs d’étalonnage de diviseur de tension/
#define DIV_1 8.785
#define DIV_2 8.785
#define DIV_3 8.785
#define DIV_4 8.785
#define DIV_5 8.785

#define V_REF 4.95 // Valeur de tension de référence ADC / calibration
#define NUM_SAMPLES 10 //Nombre d’échantillons analogiques à prendre par la lecture, par canal

int sum[4] = {0}; // Sommes d’échantillons prélevés
unsigned char sample_count = 0; // Taille de l’échantillon
float voltage[4] = {0.0}; // Tensions calculées
char l_cnt = 0; // Utilisé dans »pour« boucles
/--------------------------------------------------------------------------/
/** Objet LCD sur les broches utilisées **/
static LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

/** Menu principal */
static const char
MAIN_MENU_ITEMS = {
“VOLTMETRE”,
“CONS ELECTRIQUE”,
“TEMPERATURE BOX”,
“COOLING”,
};
static const Menu_t MAIN_MENU = {
“Votre choix ?”,
MAIN_MENU_ITEMS,
4,
&doMainMenuAction
};

/* Sous menu pour Point de rosée /
static const char
COOLING_MENU_ITEMS = {
“POINT DE ROSEE”,
“CCD FRECH”

};
static const Menu_t COOLING_MENU = {
“Votre choix ?”,
COOLING_MENU_ITEMS,
1,
&doCoolingMenuAction
};
/--------------------------------------------------------------------------/
/*Instructions à n’exécuter qu’une seule fois/
void setup(){
Wire.begin(); //Initialisation I2C (24LC256), Arduino en mâtre
unsigned int address = 0;

writeEEPROM(disk1, address, 123);
Serial.print(readEEPROM(disk1, address), DEC);
{
Serial.begin(9600);
/* Configuration du LCD */
lcd.begin(16, 4);
{
/Message de bienvenue/
lcd.setCursor(0,00); //En haut à gauche (numéroté depuis 0)
lcd.print(“Alim Astronomie”); // Afficher un petit message
lcd.setCursor(0,01); //Ligne du bas
lcd.print(“Mogenot D. V3”); // Afficher un petit message
lcd.setCursor(0,02); //Ligne du bas
lcd.print(“10/04/2015”); // Afficher un petit message

delay(5000); //intro de 5 secondes-

lcd.setCursor(0,1); //Ligne du bas
lcd.print(" “); //Effacer cette ligne
lcd.setCursor(0,0);
lcd.print(” “); //Effacer cette ligne
lcd.setCursor(0,02);
lcd.print(” "); //Effacer cette ligne
delay(2000); //intro de 2 secondes-
{
pinMode (13, OUTPUT);//Sortie relais ouvert
}
}
}
}
/--------------------------------------------------------------------------/
/*Instructions qui seront répétees indéfiniment/
void loop(){}

void writeEEPROM(int deviceaddress, unsigned int eeaddress, byte data )
{
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // MSB
Wire.write((int)(eeaddress & 0xFF)); // LSB
Wire.write(data);
Wire.endTransmission();

delay(5);
}

byte readEEPROM(int deviceaddress, unsigned int eeaddress )
{
byte rdata = 0xFF;

Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // MSB
Wire.write((int)(eeaddress & 0xFF)); // LSB
Wire.endTransmission();

Wire.requestFrom(deviceaddress,1);

if (Wire.available()) rdata = Wire.read();

return rdata;
{
digitalWrite (13, HIGH); //Sortie relais niveau logique haut
delay (1000); //Délai d’anti-rebondissement
}
}
{

/* Affiche le menu principal */
displayMenu(MAIN_MENU);

/* Démo pour montrer la sortie du menu */
lcd.clear();
lcd.print(F(“Menu ferme”));
delay(2000);
}

void aiguillage(int choix_utilisateur)
{
switch (choix_utilisateur)
{
case 0:
Serial.print("aiguillage = ");Serial.println(“voltmetre”);
Voltmetre ();
break;
case 1:
Serial.print("aiguillage = ");Serial.println(“cons electrique”);
// Cons_Electrique ();
break;
case 2:
Serial.print("aiguillage = ");Serial.println(“Temperature box”);
// Temperature_Box ();
break;
case 3:
Serial.print("aiguillage = ");Serial.println(“Cooling”);
// Cooling();
break;

}
}

/** Fonction retournant le bouton appuyé (s’il y en a un). */
Button_t readPushButton(void) {

/* Lecture de l’entrée A0 */
unsigned int val = analogRead(A0);

/* Test suivant les fourchettes de valeurs */
if (val > 1000) return BP_NONE;
if (val < 50) return BP_RIGTH;
if (val < 195) return BP_UP;
if (val < 380) return BP_DOWN;
if (val < 555) return BP_LEFT;
if (val < 790) return BP_SELECT;

/* Par défaut aucun bouton n’est appuyé */
return BP_NONE;
}

/** Affiche le menu passé en argument */
void displayMenu(const Menu_t &menu) {

/* Variable pour le menu */
byte selectedMenuItem = 0; // Choix selectionné
byte shouldExitMenu = false; // Devient true quand l’utilisateur veut quitter le menu
Button_t buttonPressed; // Contient le bouton appuyé

/* Tant que l’utilisateur ne veut pas quitter pas le menu */
while (!shouldExitMenu) {

/* Affiche le menu */
lcd.clear();
lcd.print(menu.prompt);
lcd.setCursor(0, 1);
lcd.print(menu.items[selectedMenuItem]);

/* Attend le relâchement du bouton */
while (readPushButton() != BP_NONE);

/* Attend l’appui sur un bouton */
while ((buttonPressed = readPushButton()) == BP_NONE);

/* Anti rebond pour le bouton */
delay(30);

/* Attend le relâchement du bouton */
while (readPushButton() != BP_NONE);

/* Gére l’appui sur le bouton */
switch (buttonPressed) {
case BP_UP: // Bouton haut = choix précédent

/* Si il existe un choix précédent */
if (selectedMenuItem > 0) {

/* Passe au choix précédent */
selectedMenuItem–;
}
break;

case BP_DOWN: // Bouton bas = choix suivant

/* Si il existe un choix suivant */
if (selectedMenuItem < (menu.nbItems - 1)) {

/* Passe au choix suivant */
selectedMenuItem++;
}
break;

case BP_LEFT: // Bouton gauche = sorti du menu
shouldExitMenu = true;
break;

case BP_SELECT: //
case BP_RIGTH: // Bouton droit ou SELECT = validation du choix
menu.callbackFnct(selectedMenuItem);
break;
}
}
}

/** Affiche le choix de l’utilisateur */
void doMainMenuAction(byte selectedMenuItem) {

/* Cas spécial pour Cooling */
if (selectedMenuItem == 2) {

/* Affiche le sous-menu pour Point de rosée */
displayMenu(COOLING_MENU);

} else {

/* Affiche le choix de l’utilisateur */
displayChoice(selectedMenuItem, MAIN_MENU_ITEMS);
}
}

/** Affiche le choix de l’utilisateur */
void doCoolingMenuAction(byte selectedMenuItem) {

/* Affiche le choix de l’utilisateur */
displayChoice(selectedMenuItem, COOLING_MENU_ITEMS);
}

/** Affiche le choix de l’utilisateur /
void displayChoice(byte selectedMenuItem, const char
* items) {

/* Affiche le choix de l’utilisateur /
lcd.clear();
lcd.print(F(“Z’avez choisi :”));
lcd.setCursor(0, 1);
lcd.print(items[selectedMenuItem]);
Serial.print("selectedMenuItem = ");Serial.println(selectedMenuItem);
/
Attend l’appui sur le bouton gauche ou SELECT */
byte buttonPressed;
do {
buttonPressed = readPushButton();
}
while (buttonPressed != BP_LEFT && buttonPressed != BP_SELECT);
aiguillage(selectedMenuItem);
}

Bonjour,
STP, mets ton code entre balises. Si tu ne sais pas c'est ICI

Bonjour.
comment implanter une scrutation par un appui bouton select par exemple, pour quitter une des fonction du menu item une fois sélectionner, pour un6 retour dans le choix des menu item

partie1

#include <LiquidCrystal.h>      // Inclut la librairie LiquidCrystal pour le LCD.
#include <Wire.h>               // Initialisation I2C (24LC512), Arduino en mâitre.    
#include <SPI.h>                // Inclut la librairie SPI communiquation périphériques.
#include <OneWire.h>            // Inclut la librairie OneWire capteur de temperature.
#include <DallasTemperature.h>  // Inclut la librairie DallasTemperture contrôle DS18B20.
#include <DHT.h>              // Inclut la librairie DTH22 capteur de temperature et d'humidité.
#include <stdio.h>              // contient les déclaration d'un ensemble de fonctions qui gèrent les entrées/sorties des programmes écrits en C.
#include "Wire.h"               // Inclut la librairie Wire permet de communiquer avec les composants utilisant le protocole I2C.
#include "Menu.h"               // Fichier d'entête avec les types pour le menu.
#include "Eeprom.h"             // Fichier source Eepprom.



#define DHTPIN 7    // sonde DHT22 raccordée sur la broche 7.
#define DHTTYPE DHT22   //Si vous utiliser le DHT 22 
#define ONE_WIRE_BUS 3 // capteur DS18B20 temperature Box raccordée sur la broche 3 (Adr: 0x28, 0xDA, 0x72, 0x50, 0x05, 0x00, 0x00, 0x16).
#define ONE_WIRE_BUS 7 // capteurs DS18B20 cooling ccd raccordée sur la broche 7.

OneWire oneWire(ONE_WIRE_BUS);       // Mise en place d'une instance OneWire Communiquer avec tous les périphérique.
DallasTemperature sensors(&oneWire); // Passez notre référence de OneWire à Dallas Température.
DeviceAddress Probe01 = { 0x28, 0x6D, 0x50, 0x51, 0x05, 0x00, 0x00, 0x60 };   // adresse a remplacer - sonde exterieur.
DeviceAddress Probe02 = { 0x10, 0x66, 0xCE, 0x0A,0x03, 0x08, 0x00, 0x83 };   // sonde peltier.
DeviceAddress Probe03 = { 0x28, 0xDA, 0x72, 0x50, 0x05, 0x00, 0x00, 0x16 };   // Sonde boitier astro systéme(ci. TS1)


#define disk1 0x50    //Adresse eeprom 24LC512 disk1
#define disk2 0x51    //Adresse eeprom 24LC512 disk2

#define NUM_SAMPLES 10 // nombre d'échantillons analogiques à prendre par la lecture, par canal.
#define V_REF    4.95  // valeurs d'étalonnage de diviseur de tension.

/*Valeur de tension de référence ADC / calibration*/
#define DIV_A1 11.133
#define DIV_A2 11.133
#define DIV_A3 11.133
#define DIV_A6 11.133

const int pinAna[]={A1,A2,A3,A6}; // Declaration pin alanog pour diviseur de tention.
int sum[4] = {0};                 // Sommes d'échantillons prélevés.
unsigned char sample_count = 0;   // Taille de l'échantillon.
float voltage[4] = {0.0};         // Tensions calculées.
char l_cnt = 0;                   // Utilisé dans »pour« boucles.

int Continuer = 1;
int lcd_key     = 0; 
int adc_key_in  = 0;
#define btnPlus5    0
#define btnPlus1    1
#define btnMoins1   2
#define btnMoins5   3
#define btnSelect   4
int Pel = 13; // Sortie relay broche 13.

float settemp; // Faire un variable appelée Température.
float compt;
float compt2;
int read_LCD_buttons()
{
 adc_key_in = analogRead(0); // Lecture entrée analogique.
 // Emlapcement d'utilisation de la touche détectée.
 if (adc_key_in < 50)   return btnPlus5;  //A droite 30
 if (adc_key_in < 195)  return btnPlus1;  //Desuus 150
 if (adc_key_in < 380)  return btnMoins1; //Dessous 360  
 if (adc_key_in < 555)  return btnMoins5; //A Gauche 535
 if (adc_key_in < 790)  return btnSelect; //Selectionner 760
}
/* Objet LCD 4 x 16 DEM16481 sur les broches utilisées  */
static LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
/* Menu principal */
static const char* MAIN_MENU_ITEMS[] = {
  "Voltmetre",   // Fonction Voltmétre.
  "Cooling",      // Fonction Cooling CCD.  
  "Temperature",  // Fonction Température du boitier astro systéme.
  "D",            // Fonction D.
  "E"             // Fonction E.
};

static const Menu_t MAIN_MENU = {
  "Selectionner",
  MAIN_MENU_ITEMS,
  5,
  &doMainMenuAction
}; 
/* Sous menu pour Système */
static const char* SYSTEME_MENU_ITEMS[] = {
  "1",
  "2",
  "3"
};
static const Menu_t SYSTEME_MENU = {
  "Selectionner",
  SYSTEME_MENU_ITEMS,
  3,
  &doSystemeMenuAction
};

/** Setup */

parti1 suite

void setup() 
{
lcd.begin(16, 4); // Démarrer la librairie lcd.  
Serial.begin(57600);  // Serial port.
Wire.begin();
{
unsigned int address = 0;
 
  writeEEPROM(disk1&2, address, 123);
  Serial.print(readEEPROM(disk1&2, address), DEC);
 }
 {
    pinMode (Pel,OUTPUT);
  sensors.begin(); // démarrage de la library des capteur DS18B20.
  sensors.setResolution(Probe01, 10);
  sensors.setResolution(Probe02, 10);
  sensors.setResolution(Probe03, 10); 
 

 /*Message de bienvenue*/
 lcd.setCursor(0,00);           // 1er ligne (numéroté depuis 0).
 lcd.print("  ASTRO SYSTEM");   // Afficher un petit message: ASTRO SYSTEM.
 lcd.setCursor(0,01);           // 2emme ligne (numéroté depuis 0).
 lcd.print("________________"); // Afficher un petit message: ________________.
 lcd.setCursor(0,02);           // 3emme Ligne (numéroté depuis 0).
 lcd.print("Mogenot Denis");    // Afficher un petit message: Mogenot Denis.
 lcd.setCursor(0,003);          // 4emme Ligne (numéroté depuis 0).
 lcd.print("version: 3  2015"); // Afficher un petit message: version: 3  2015.
 delay(5000);  //intro de 5 secondes-.
 lcd.clear(); 
}
 } 
 
/** Programme principal */
void loop() {
 
  /* Affiche le menu principal */
  displayMenu(MAIN_MENU);
 
  /* Démo pour montrer la sortie du menu */
  lcd.clear();
  lcd.print(F("Menu ferme"));
  delay(2000);
} 
/** Fonction retournant le bouton appuyé (s’il y en a un). */
Button_t readPushButton(void) {
 
  /* Lecture de l'entrée A0 */
  unsigned int val = analogRead(A0);
 
  /* Test suivant les fourchettes de valeurs */
  if (val > 1000) return BP_NONE;
  if (val < 50) return BP_RIGTH;  
  if (val < 195) return BP_UP; 
  if (val < 380) return BP_DOWN; 
  if (val < 555) return BP_LEFT; 
  if (val < 790) return BP_SELECT;
 
  /* Par défaut aucun bouton n'est appuyé */
  return BP_NONE;
}
/** Affiche le menu passé en argument */
void displayMenu(const Menu_t &menu) {
 
  /* Variable pour le menu */
  byte selectedMenuItem = 0;   // Choix selectionné.
  byte shouldExitMenu = false; // Devient true quand l'utilisateur veut quitter le menu.
  Button_t buttonPressed;      // Contient le bouton appuyé.
 
  /* Tant que l'utilisateur ne veut pas quitter pas le menu */
  while(!shouldExitMenu) {
 
    /* Affiche le menu */
    lcd.clear();
    lcd.print(menu.prompt);
    lcd.setCursor(0, 1);
    lcd.print(menu.items[selectedMenuItem]);
    
    while(readPushButton() != BP_NONE); // Attend le relâchement du bouton. 
    while((buttonPressed = readPushButton()) == BP_NONE); // Attend l'appui sur un bouton.
 
    delay(30); // Anti rebond pour le bouton.
 
    while(readPushButton() != BP_NONE); //Attend le relâchement du bouton.
 
    /* Gére l'appui sur le bouton */
    switch(buttonPressed) {
    case BP_UP: // Bouton haut = choix précédent.
      
      if(selectedMenuItem > 0) {  // Si il existe un choix précédent.
 
               selectedMenuItem--;  // Passe au choix précédent.
      }
      break;
 
    case BP_DOWN: // Bouton bas = choix suivant.
      
      if(selectedMenuItem < (menu.nbItems - 1)) {  // Si il existe un choix suivant.
        
        selectedMenuItem++;  // Passe au choix suivant.
      }
      break;
      
    case BP_LEFT: // Bouton gauche = sorti du menu.
      shouldExitMenu = true;
      break;
      
    case BP_SELECT: //
    case BP_RIGTH:  // Bouton droit ou SELECT = validation du choix.
      menu.callbackFnct(selectedMenuItem);
      break;
    }
  }
}
 
/** Affiche le choix de l'utilisateur */
void doMainMenuAction(byte selectedMenuItem) {
  /* Gère le choix de l'utilisateur */
  
  switch(selectedMenuItem) {
  
  /** Fonction voltmetre **/
    case 0: 
  void Voltmetre(); 
    break;
   /** Fonction cooling ccd **/
  case 1: 
   void Cooling();
    break;
   /** Fonction Temperature **/
  case 2:
   void Temperature();
    break;
     /** Fonction Dew point **/
  case 3:
    void Dewpoint();
    break;
     /** Fonction kwh **/
  case 4:
    // Code pour le choix 4 
    break;
 
    // etc ...
 } 

  /* Cas spécial pour Système */
  if(selectedMenuItem == 2) {
 
    /* Affiche le sous-menu pour Système */
    displayMenu(SYSTEME_MENU);
 
  } else {
 
    /* Affiche le choix de l'utilisateur */
    displayChoice(selectedMenuItem, MAIN_MENU_ITEMS);
  }
}

 
/** Affiche le choix de l'utilisateur */
void doSystemeMenuAction(byte selectedMenuItem) {
 
  /* Affiche le choix de l'utilisateur */
  displayChoice(selectedMenuItem, SYSTEME_MENU_ITEMS);
}
 
/** Affiche le choix de l'utilisateur */
void displayChoice(byte selectedMenuItem, const char** items) {
 
  /* Affiche le choix de l'utilisateur */
  lcd.clear();
  lcd.print(F("Valider:"));
  lcd.setCursor(0, 1);
  lcd.print(items[selectedMenuItem]);
 
  /* Attend l'appui sur le bouton gauche ou SELECT */
  byte buttonPressed;
  do {
    buttonPressed = readPushButton();
  } 
  while(buttonPressed != BP_LEFT && buttonPressed != BP_SELECT);
}

onglet cooling

/*

 Regulation de température ccd
  Relai broche D13
  Sondes broche D7
  
 */

void Cooling() // Fonction Cooling Ccd.
{
   int temp1 = sensors.getTempC(Probe01);
   sensors.requestTemperatures(); // envoyer la commande pour obtenir les temperatures 
   
   lcd.setCursor(0,00);       // 1er ligne (numéroté depuis 0)
   lcd.print("Tp. BOX:");   // Afficher un petit message: Tp local 
   printTemperature(Probe01); // Afficher température exterieur
   lcd.print((char)223);      // Affiche: le caractère ° (degrés)
   lcd.setCursor(14,00);      // 1emme ligne (numéroté depuis 14).
   lcd.print("C");            // Affiche en degrés Celsuis C
    
   lcd.setCursor(0,01);       // 2emme ligne (numéroté depuis 0)
   lcd.print("Tp. CCD:");   // Afficher un petit message: Tp CCD 
   printTemperature(Probe02); // Afficher température pelletier
   lcd.print((char)223);      // Affiche: le caractère ° (degrés)
   lcd.setCursor(14,01);      // 1emme ligne (numéroté depuis 14).
   lcd.print("C");            // Affiche en degrés Celsuis C
    
   lcd.setCursor(0,02);       // 3emme ligne (numéroté depuis 0)
   lcd.print("Index    : ");  // Afficher un petit message: index
   lcd.print(settemp);        // Consigne de température
   lcd.print((char)223);      // Affiche: le caractère ° (degrés)
   lcd.setCursor(14,02);      // 1emme ligne (numéroté depuis 14).
   lcd.print("C");            // Affiche en degrés Celsuis C
     
     /* affichage On ou Off du relay suivant consigne */
   if (settemp < temp1 )
   {
     digitalWrite(Pel,LOW);
     lcd.setCursor(0,03);      // 4emme ligne (numéroté depuis 0)
     lcd.print("Fonction :");  // Afficher un petit message: fonction
     lcd.print ("  Off");      // Afficher un petit message: Off suivant temperature de consigne
   }
   else
   {
     digitalWrite(Pel,HIGH);
     lcd.setCursor(0,03);      // 4emme ligne (numéroté depuis 0)
     lcd.print("Fonction :");  // Afficher un petit message: fonction
     lcd.print ("  On");       // Afficher un petit message: On
   } 
   
  delay (100); 

  settemp = (compt*0.5)+(compt2*5);
  
  // possibilité d'augmenter la précision de la consigne incrément 0.5 
  //settemp = (compt*0.5);
  
 lcd_key = read_LCD_buttons();
 switch (lcd_key) 
 {
   case btnPlus1:   // BP_UP plus 1°C
     {
     (compt ++);
      break;
       delay(20);   // Délai d'anti-rebondissement
     }
   case btnMoins1:  // BP_DOWN moins 1°C
     {
     (compt --);
     break;
     delay(20);     // Délai d'anti-rebondissement
     }
   case btnPlus5:   // BP_RIGTH plus 5°C
     {
     (compt2 ++);   
     break;
     delay(20);     // Délai d'anti-rebondissement
     }
   case btnMoins5:  // BP_LEFT moins 5°C
     {
     (compt2 --);   
     break;
     delay(20);     // Délai d'anti-rebondissement   
     }
   }   
}
void printTemperature(DeviceAddress deviceAddress)
{
float tempC = sensors.getTempC(deviceAddress);

   if (tempC == -127.00)
   {
    lcd.print("Erreur");
   }    
   else
   { 
    
   lcd.print(tempC);   
   }
   }