Régulation de temperature

Bonjour à tous,

Je viens de finir de construire un poêle à bois pour ma micro caravane.
mon poêle ne sera bien évidemment pas à l'intérieur de la caravane mais à l'extérieur dans le auvent.

J'ai réalisé un échangeur de chaleur sur ce poêle pour canaliser de l'air chaud à l'intérieur de l'habitacle de la caravane.

J'aimerais réguler la température via la vitesse de rotation du ventilateur qui pousse l'air chaud du poele vers la caravane à l'aide d'un pont en H l298n ainsi que de deux sondes de température DS18 B20.

Mon matos :

  • pont en H L298n
  • sondes de températures DS18B20 (sortie d'air chaud et habitacle)
  • ventilo de pc 12v
  • carte nano

Fonctionnement :

l'une des deux sondes mesure la température ambiante de la caravane quant à l'autre elle mesure la température de sortie d'air chaud dans l'habitacle.

Tant que la chaleur n'atteind pas la consigne donnée ''19°'' le ventilo tourne à fond. Quand la consigne est atteinte le ventilo tourne à 20 %.

Lorsque la sonde de sortie de chaleur indique une température inférieure à la sonde d'ambiance le ventilateur se coupe (cela signifie que le poêle et sûrement éteint.) pour ne pas refroidir l'habitacle.

Et le top du top serait d'avoir un interrupteur supplémentaire pour pouvoir choisir entre deux consignes l'une à 16 pour la nuit et l'autre à 20 pour la journée.

Ma question est donc la suivante, quelqu'un aurait-il croisé au hasard d'une recherche, un système similaire ou une piste de recherche pour que je puisse commencer mon code ??

D'avance merci pour votre aide.
Peyo.

Salut !

Je ne suis qu'un débutant, mais à voir comme ça le problème serait juste un contrôle de la température et une activation si la bonne condition est vérifié ?

Je n'ai jamais utilisé de ventilateur, mais si on le remplace par un moteur, je ferai une boucle if qui dit que si la température n'est pas à 19, le moteur tourne a sa vitesse max, sinon à 20% et une troisième condition pour arreter le ventilo.

Par contre je te conseille de mettre en place un système d'hystérésis, car si tu es au voisinage de ta température de consigne, le ventilo va s'arreter puis se couper puis se rallumer etc sans cesse, car tu passeras au dessus puis en dessous puis au dessus...

Il faut donc que le moteur tourne quand la température dépasse 20 degré C (par exemple) mais qu'il s'arrête seulement quand la température tombe sous 18 degré C

Pour l'interrupteur, je te dirai de mettre un compteur qui compte lorsque tu appuies :
Qd il est à 0 : température de consigne à 20 pour la journée et si tu appuies, le compteur passe à 1
Qd il est à 1 : température de consigne à 16 pour la nuit et si tu appuies, le compteur passe à 0

Voila je ne peux pas t'aider plus, il y a surement de meilleures solutions utilisable mais je ne suis pas super expérimenter :confused:

De plus, je ne comprend pas ici l'importance du pont en H ? C'est pour alimenter ton ventilo 12 V ? Pourquoi ne pas passer par un transistor ?

J'espère quand même avoir pu t'aider ! :slight_smile:

Un code tout fait qui ressemble à ce que tu veux faire n'y comptes pas trop.

Par contre des exemples pour chacunes des fonctions ne devraient pas être trop difficile à trouver, surtout avec le moteur de recherche du forum.

Je pense que si, dans un premier temps, tu laissais ton projet global de coté et que tu apprenais à gérer individuellement un DS18B20, un moteur, etc tu progresserai plus vite dans la réalisation de ton projet.

Remarque :
Le ventillateur est quel type ? Motif de la question : le mode de commande dépendra de son type technologique. Il existe différenes technologies : moteur à courant continu classique, moteur "brushless", ? .
Note le l298N a des caractéristiques bien définies, il faut t'assurer qu'il est capable de commander le ventilateur avant de commencer le cablâge.

Conseil : tu as tout intéret à utiliser le tuto d'Eskimon dont un lien est donné dans le message épinglé "Règles du forum francophone". C'est ce que l'on fait de mieux.

Il n'est pas évident qu'un organe de puissance soit nécessaire. Tout dépend du ventilateur, 2 ou 3 ou 4 broches.
arduino-pilotage-de-ventilateurs.html

Un pont en H L298 n'a d'intérêt que si l'on désire faire tourner le moteur dans les 2 sens.
S'il s'agit d'un ventilateur 2 ou 3 broches un simple transistor suffit.

Sauf si c'est petit ventilateur à moteur brushless.

Ma remarque était générale : on ne décide pas de l'organe de puissance sans connaitre ce que l'on a à commander.
Et bien sur, comme demandé dans le message "Règle du forum francophone", quand on pose une question on donne tous les renseignements immédiatement ou on dit qu'on ne sait pas mais au moinsc'est clair.

Rien n'est plus pénible que de les obtenir un par un.

Tout à fait d'accord.

Bonsoir et merci pour vos réponses,
J'ai essayé de penser à tout mais visiblement je n'ai pas réussi,
Je complète, j'utilise un ventilo de pc à Courant continu.
12v 2,4w.
Je pensais utiliser un l298n car je maîtrise bien sa prog,
En faite je maîtrise la prog de tous les organes mais c'est la trame du programme générale que je ne trouve pas.
J'imaginais une machine à état, mais je préférai demander conseil avant de me lancer..

Je n'ai jamais utilisé de transistor seul mais je vais regarder de plus près.

Merci pour le conseil.
Bonne soirée à tous.

J'ai essayé de penser à tout mais visiblement je n'ai pas réussi,
Je complète, j'utilise un ventilo de pc à Courant continu.

Tu en as encore oublié : 2 fils, 3 fils, 4 fils ? ? ?

Quelle est la température de l'air en sortie de l'échangeur de chaleur?
Le ventilateur va la supporter?

:confused: oui désolé, 2 fils pour mon ventilo un rouge un noir, longueur 20cm diamètre 1,23mm.
Il a 7 pales noires, 6000tr/min 45db 120mcube heure, dim 80x80mm. Et il s'appelle Marcel (chauffe Marcel)

Un transistor 2n2222 peut il suffire où il faut un MOSFET?

Aucun risque pour la température, le ventilateur n'est pas en sortie mais en entrée de l'échangeur et il pousse l'air dans celui-ci..

Merci.

Sous 12V et une puissance aussi faible un 2N2222 suffit amplement.

Entre nous 6000tr/min cela fait beaucoup et cela va s'entendre (45 db). En le sous-alimentant pour réduire le bruit le débit va en souffrir.
Pourquoi ne pas opter plutôt pour un 200mm ?
Un Noctua NF-A20 PWM :
800 tr/min maxi
18.1 dB maxi
146.9 m³/h maxi

Très bonne idée, en plus il est carrément plus beau :slight_smile:
C'est simplement parsqu'on me l'a donné mais je pourrais effectivement le remplacer par un moins bruyant !

Il se commande avec une simple sortie PWM sans transistor, peut être en 500Hz (à essayer) mais plus probablement à 31KHz : voir mon article en #3.

Bonsoir,
j'ai avancé sur mon code, il ne me manque que la comparaison entre entrée et sortie pour couper le ventilo si le poêle s’éteint... donc lire un second capteur... :o
Vous pensez que c'est jouable avec ce début de code ?

j'ai finalement opté pour mon bon vieux L298N... je pourrai mettre un sèche cheveux au besoin :slight_smile:

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

//---- code des instructions du capteur
const int modeLecture=0xBE;
const int lancerMesure=0x44;

// --- constantes des broches ---

const int broche_OneWire=2; //declaration constante de broche

// --- Déclaration des variables globales ---
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;

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---
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); //Déclare BOUTON comme une entrée
  digitalWrite(13, HIGH);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT); 
  
// --- ici instructions à exécuter au démarrage ---
Serial.begin(115200); // initialise connexion série à 115200 bauds

// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission


// --- 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);            //Switch between this HIGH and LOW to change direction
  digitalWrite(in2, HIGH);
  speed1 = analogRead(A0);
  speed1 = speed1 * 0.2492668622;      //We read thea analog value from the potentiometer calibrate it
  analogWrite(ConA, speed1);            // Then inject it to our motor
}
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;

return (tempetf);

if (tempetf<17)
digitalWrite(in1, LOW);            //Switch between this HIGH and LOW to change direction
  digitalWrite(in2,HIGH);
  analogWrite(ConA, 255);
  return (tempetf);

  if (tempetf>17 && tempetf<18)
 digitalWrite(in1, LOW);            //Switch between this HIGH and LOW to change direction
  digitalWrite(in2,HIGH);
  analogWrite(ConA, 200);
  return (tempetf);
  
if (tempetf>18 && tempetf<19)
ddigitalWrite(in1, LOW);            //Switch between this HIGH and LOW to change direction
  digitalWrite(in2,HIGH);
  analogWrite(ConA,150);
  return (tempetf);
  
 if (tempetf>19 && tempetf<20)
 digitalWrite(in1, LOW);            //Switch between this HIGH and LOW to change direction
  digitalWrite(in2,HIGH);
  analogWrite(ConA,100);
  return (tempetf);

if (tempetf>20)
 digitalWrite(in1, LOW);            //Switch between this HIGH and LOW to change direction
  digitalWrite(in2,HIGH);
  analogWrite(ConA, 50);
  return (tempetf);
}
// --------------- fin de la fonction de mesure de la température ----------

// --- Fin programme ---

Merci

Tu pourrais au minimum indenter le code (CTRL-T) et le compiler.

  tempetf = tempetf / 100.0;

  return (tempetf);    // ? ? ?
  // tu penses vraiment que la suite de tests suivants va s'exécuter ?

  if (tempetf < 17)       // accolades manquantes
    digitalWrite(in1, LOW);            //Switch between this HIGH and LOW to change direction
  digitalWrite(in2, HIGH);
  analogWrite(ConA, 255);
  return (tempetf);

Ensuite à toi de tester.

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)

//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 ---

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.

//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 ---////////////////////////////////////