Go Down

Topic: Régulation de temperature (Read 409 times) previous topic - next topic

peyodu5656


Merci  hbachetti  pour les conseils, effectivement ça marche nickel avec ces deux modifs!!
Il ne me reste plus qu'à trouver la solution pour mettre deux sondes et comparer leur valeur pour couper le système si le poêle s'éteint... si quelqu'un à une piste.. Merci d'avance!
Bonne journée à tous.

 (je joint le code fonctionnel)



Code: [Select]
//automate pour poele à bois avec échangeur de chaleur pour chauffage caravane.
// une sonde de température un ventilo 12v un potentiometre et une carte nano

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

//---- code des instructions du capteur
const int modeLecture=0xBE;
const int lancerMesure=0x44;
const int broche_OneWire=2; //declaration constante de broche
byte data[12]; // Tableau de 12 octets pour lecture des 9 registres de RAM et des 3 registres d'EEPROM du capteur One Wire
byte adresse[8]; // Tableau de 8 octets pour stockage du code d'adresse 64 bits du composant One Wire

float ma_tempetf=0.0;

int in1 = 8;        //Declaring where our module is wired 
int in2 = 9;
int ConA = 10;     // Don't forget this is a PWM DI/DO   
int speed1;
int BOUTON = 7;

OneWire  capteur(broche_OneWire);  // crée un objet One Wire sur la broche voulue

void setup() {
 
  pinMode(13, OUTPUT); //LED temoin de marche
  pinMode(BOUTON, INPUT); //BOUTON auto/manu
  digitalWrite(13, HIGH);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
 
Serial.begin(115200); // initialise connexion série à 115200 bauds

// --- initialisation du capteur DS18B20 ------

capteurInit(); // appel de la fonction d'initialisation du capteur - au début seulement
// prise en compte du premier capteur trouvé
 
}

void loop() {

if (digitalRead(BOUTON) == HIGH) //mode manuel
{digitalWrite(in1, LOW);     
  digitalWrite(in2, HIGH);
  speed1 = analogRead(A0);
  speed1 = speed1 * 0.2492668622;     
  analogWrite(ConA, speed1);           
}


else { //mode auto
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
{
// XXXXXXXXXXXXXXXXXXXXXX Détection du capteur présent sur la broche XXXXXXXXXXXXXXXXXXXXXXX
Serial.println("**** Detection du capteur **** ");

while (capteur.search(adresse)== false) // tant qu'aucun nouveau capteur est détecté
{

 // la fonction search renvoie la valeur FAUX si aucun élément 1-wire est trouvé.

 Serial.println("Aucun capteur 1-wire present sur la broche ! "); // affiche message + saut de ligne
 delay (1000); // pause 1 seconde
}

//la suite est exécutée seulement si un capteur est détecté

 // la fonction search renvoie la valeur VRAI si un élément 1-wire est trouvé.
 // Stocke son code d'adresse 16 bits dans le tableau adresse[8]
 // adresse envoyé à la fonction correspond à l'adresse de début du tableau adresse[8] déclaré ... 

 Serial.print ("1 capteur 1-wire present avec code adresse 64 bits : ");


 //--- affichage des 64 bits d'adresse au format hexadécimal
  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();

 //---- test du type de capteur ----
 // le type du capteur est donné par le 1er octet du code adresse 64 bits
 // Valeur 0x28 pour capteur type DS18B20, 0x10 pour type DS18S20, 0x22 pour type DS1820
 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.");
 }


 //----- contrôle du code CRC ----
 // le dernier octet de l'adresse 64bits est un code de contrôle CRC
 // à l'aide de la fonction crc8 on peut vérifier si ce code est valide
 if (capteur.crc8( adresse, 7) == adresse[7]) // vérification validité code CRC de l'adresse 64 bits
 // le code CRC de l'adresse 64 bits est le 8ème octet de l'adresse (index 7 du tableau)
 {
   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(""); 
}
//----------- fin de la fonction d'initialisation du capteur ----------


//-------------- fonction de mesure de la température ---------------

float capteurMesureTemp(void) { //fonction qui renvoie résultat float et ne reçoit rien

  //-------- variable locale de la fonction ----------
 int tempet=0; // variable pour resultat brute  de la mesure
 float tempetf=0.0; // variable pour resultat à virgule de la mesure

// XXXXXXXXXXXXXXXXXXXXXX Lancement d'une mesure et lecture du résultat XXXXXXXXXXXXXXXXXXXXXXX

// Serial.println("**** Acquisition d'une mesure de la temperature **** ");

 // avant chaque nouvelle instruction, il faut :
 //    * initialiser le bus 1-wire
 //    * sélectionner le capteur détecté
 //    * envoyer l'instruction

//--------- lancer une mesure --------
 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

//-------- pause d'une seconde -----
delay(1000);     // au moins 750 ms
          // il faudrait mettre une instruction capteur.depower ici, mais le reset va le faire


//---------- passer en mode LECTURE -------------
 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

// ----------- lire les 9 octets de la RAM (appelé Scratchpad) ----

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
 }


//----- caclul de la température mesurée (enfin!) ---------

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

// --- en mode 12 bits, la résolution est de 0.0625°C - cf datasheet DS18B20
tempetf=float(tempet)*6.25;
tempetf=tempetf/100.0;

//fonctions pour la régulation de vitesse du ventilateur en PWM sur le L298N entré ConA en fonction de la température

if (tempetf<17){
digitalWrite(in1, LOW);           
  digitalWrite(in2,HIGH);
  analogWrite(ConA, 255);
  return (tempetf);}

  if (tempetf>17 && tempetf<18){
 digitalWrite(in1, LOW);           
  digitalWrite(in2,HIGH);
  analogWrite(ConA, 220);
  return (tempetf);}
 
if (tempetf>18 && tempetf<19){
digitalWrite(in1, LOW);           
  digitalWrite(in2,HIGH);
  analogWrite(ConA,180);
  return (tempetf);}
 
 if (tempetf>19 && tempetf<20){
 digitalWrite(in1, LOW);           
  digitalWrite(in2,HIGH);
  analogWrite(ConA,120);
  return (tempetf);}

if (tempetf>20){
 digitalWrite(in1, LOW);           
  digitalWrite(in2,HIGH);
  analogWrite(ConA, 70);
  return (tempetf);}
}
// --------------- fin de la fonction de mesure de la température ----------

// --- Fin programme ---


                                 



peyodu5656

salut,
j'ai terminé mon  code, tout marche nickel donc je partage !
Idée : gérer la température à l'intérieur de ma caravane.
j'utilise un poêle à bois avec échangeur de chaleur.
je régule la température intérieure via la vitesse du ventilo.


Code: [Select]
//automate pour poele à bois avec échangeur de chaleur pour chauffage caravane.
// 2 sondes de température un ventilo 12v un potentiometre et une carte nano

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

OneWire ds(6);  // sondes sur le pin 6

byte addr1[8] = {
  0x28, 0xD8, 0x68, 0x3E, 0x3A, 0x19, 0x01, 0xBD};//capteur température int
byte addr2[8] = {
  0x28, 0x8F, 0x1C, 0x5D, 0x3A, 0x19, 0x01, 0x7C};//capteur température sortie hot
int SignBit = 0;
int StartCol = 8;

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int in1 = 8;        //entrées pour Ln298N
int in2 = 9;        //entrées pour Ln298N
int ConA = 10;      //entrée en PWM pour L298N
int speed1;         //vitesse definie via potensiometre
int BOUTON1 = 7;    //bouton manu/auto
int BOUTON2 = 13;   //bouton consigne
int valtempin;      //variable de la température interieur
int valtemphot;     //variable température de sortie d'air chaud
int cons ;          //variable de température de consigne



void setup() {

  pinMode(BOUTON2,INPUT);     //bouton consignes
  pinMode(BOUTON1, INPUT);    //BOUTON auto/manu
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);

  Serial.begin(9600);
  // colones et lignes lcd
  lcd.begin(16, 2);
  // Print le message sur le LCD.
  lcd.print("Tint:");
  lcd.setCursor(0, 1);
  lcd.print("Thot:");

}
int tc_100(byte* addr) {
  int HighByte, LowByte, TReading;
  byte data[12];
  byte i;

  ds.reset();
  ds.select(addr);
  ds.write(0x44, 1);

  delay(1000);              // defini le nombre de mesrures par seconde


  ds.reset();
  ds.select(addr);
  ds.write(0xBE);           

  for ( i = 0; i < 9; i++) { 
    data[i] = ds.read();
  }

  LowByte = data[0];
  HighByte = data[1];
  TReading = (HighByte << 8) + LowByte;
  SignBit = TReading & 0x8000;     // test most sig bit
  if (SignBit)                     // si negatif
  {
    TReading = (TReading ^ 0xffff) + 1;     // 2's comp
  }
  return (6 * TReading) + TReading / 4;     // multipli par (100 * 0.0625) or 6.25
}

//////////////////Void pour écriture de la température des sondes//////////////////////////////

void mypr(int Tc_100, int line) {
  int Whole, Fract;

  Whole = Tc_100 / 100; 
  Fract = Tc_100 % 100;

  if (SignBit) // si temp negative
  {
    lcd.setCursor(StartCol, line);
    lcd.print("-");
  }
  lcd.setCursor(StartCol + 1, line);
  lcd.print(Whole);
  lcd.print(".");
  if (Fract < 10)
  {
    lcd.print("0");
  }
  lcd.print(Fract);
  lcd.print("C");
}

///////////////////////////////////////////////////boucle du programme//////////////////////////////////////////////////////

void loop() {

  byte i;
  byte data[12];
  int Tc_100;

  Tc_100 = tc_100(addr1);
  mypr(Tc_100, 0);

  Tc_100 = tc_100(addr2);
  mypr(Tc_100, 1);

  ///////////lectre Temperature de consigne////////////////////

  if ( digitalRead(BOUTON2) == HIGH){ //////bouton 2 defini le mode jour (20deg et nuit 17deg)
    cons = 1700 ;
  }

  else {
    cons = 2000 ;
  }


  ///////////////mode manuel//////////////////////

  if (digitalRead(BOUTON1) == HIGH)

  {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    speed1 = analogRead(A0);
    speed1 = speed1 * 0.2492668622;
    analogWrite(ConA, speed1);
  }

  ////////////////mode auto/////////////////////////
  else {
    byte i;
    byte data[12];
    int Tc_100;

    Tc_100 = tc_100(addr1);
    mypr(Tc_100, 0);
    valtempin = tc_100(addr1);

    Tc_100 = tc_100(addr2);
    mypr(Tc_100, 1);
    valtemphot = tc_100(addr2);


    if ( valtempin > valtemphot) { //sécurité si le poele vient à s'éteindre
      digitalWrite(in1, LOW);
      digitalWrite(in2, LOW);
      analogWrite(ConA, 0);
    }
    if ( valtempin < cons && valtempin < valtemphot) { //vetilletion à fond si consigne non atteinte
      digitalWrite(in1, LOW);
      digitalWrite(in2, HIGH);
      analogWrite(ConA, 255);
    }

    if ( valtempin > cons && valtempin < valtemphot) { //régulation de la vitesse du ventilo si consigne atteinte
      digitalWrite(in1, LOW);
      digitalWrite(in2, HIGH);
      analogWrite(ConA, 140);
    }

  }
}


//////////////////////////// --- Fin programme ---////////////////////////////////////








Go Up