regulation chauffage probleme sur plusieur fonction

bonjours, j’ai bien avancer mon code mais là je suis bloqué, je n’arrive pas résoudre mes problèmes.

description du programme :
En fonction de la température extérieur et la température intérieur voulu, je définis la valeur de température de départ chauffage qu’il faut.
je la compare a la valeur de la sonde et en fonction du résultat j’alimente soit le relais pour l’ouverture de l’ électrovanne soit celui de la fermeture.

J’ai déjà demander de l’aide sur ce forum pour une temporisation de mais relais , je souhaité action un relais 2 secondes et attendre 2 minute.(pour permettre a la sonde de départ de prendre en compte le changement de température).

Maintenant , je souhaite alimenter le relai 2 secondes si la différence de temp. entre la sonde départ et la valeur de température départ et inférieur a 5 °, et l’alimenter 5 secondes si la différence de temp et supérieur a 5°.
J’ai réussi sa fonctionne, mais il y a un bug a un moment les deux relais s’alimentent en même temps pendant un fraction de secondes(très bref ).

Ensuite dans ma fonction gestion auto j’ai un problème avec une boolean que je n’arrive pas a remettre a l’état false, je ne voit ou peut etre le problème.

Et puis le dernier problème ,c’est dans ma fonction conso fioul , je ne sais pas comment m’y prendre.

Voila sa fait beaucoup mais je suis perdu j’ai besoin d’aide.
Je ne peut pas mettre le code en entier ,il est trop long.
il est a télécharger.

 void ouverure_vanne_radiateur (){

// ouverture de la vanne 2seconde
   
   if (valeur_temp_dep >(moyenne_sonde_dep_radiateur + valeur_d_ecart)){
   /*int resultat = valeur_temp_dep - moyenne_sonde_dep_radiateur;
     if( resultat <5){ */
     miseAJour_ouverture();    
    // }
   }
   else{
   digitalWrite(ouverture,LOW);
   }
}

/*
//----------------------------------------------------------
void ouverure_vanne_radiateur_longue (){

// ouverture de la vanne 5 seconde
   
   if (valeur_temp_dep >(moyenne_sonde_dep_radiateur + valeur_d_ecart)){
   int resultaT = valeur_temp_dep - moyenne_sonde_dep_radiateur;
     if( resultaT >5){ 
     miseAJour_ouverture_longue();    
     }
   } 
   else{
   digitalWrite(ouverture,LOW);
   }
}
*/
//----------------------------------------------------------  
void fermeture_vanne_radiateur (){

//fermeture de la vanne 2 secondes

  if(valeur_temp_dep <(moyenne_sonde_dep_radiateur - valeur_d_ecart)){
     /*int resultat1 = moyenne_sonde_dep_radiateur - valeur_temp_dep ;
     if( resultat1 <5){*/
     miseAJour_fermeture();
    // }
  }   
  else{
  digitalWrite(fermeture,LOW);
  }
}

/*
//----------------------------------------------------------  
void fermeture_vanne_radiateur_longue (){

//fermeture de la vanne 5 secondes

  if(valeur_temp_dep <(moyenne_sonde_dep_radiateur - valeur_d_ecart)){
     int resultat2 = moyenne_sonde_dep_radiateur - valeur_temp_dep ;
     if(resultat2 >5){
     miseAJour_fermeture_longue();   
     }
  }
  else{
  digitalWrite(fermeture,LOW);
  }
}

dernier_version_regul_chaudiere.ino (26.4 KB)

parti conso fioul
je souhaite mesurer le temps de fonctionnement du bruleur

void conso_fioul(){
  
DateTime now = RTC.now();
 int depart;
 int fin;
  
  if(etat_bruleur == 1){
   DateTime depart = RTC.now(); 
  }
  else{
    if(etat_bruleur == 0){
   DateTime fin = RTC.now();
  }
 }
  tps_de_marche_bruleur = (fin - depart);
}

et la parti ou la boolean me pose problème :

void gestion_auto(){


etat_bp_auto=digitalRead(bp_auto);

 if ((etat_bp_auto!= memoire_bp_auto) && (etat_bp_auto==HIGH)){
    
    if (etat_mode_auto == false){
      etat_mode_auto = !etat_mode_auto ;
       jours_nuit(); 
     
     }
    } 
 memoire_bp_auto = etat_bp_auto;

etat_bp_auto=digitalRead(bp_auto);

if ((etat_bp_auto!= memoire_bp_auto) && (etat_bp_auto==LOW)){
     if (etat_mode_auto == true){
        etat_mode_auto = !etat_mode_auto ;
     }
   }

 memoire_bp_auto = etat_bp_auto;
 
}

En regardant vite la fonction du calcul de temps de marche du brûleur …

Pour mémoriser la dota de mise en route il faut vérifier que le brûleur était à l’arrêt juste avant… comme tu fais, la variable départ est initialisée à RTC.now tant que le brûleur est en marche …

Je ferai un truc du genre (sachant que départ=0 au lancement du prog):

Si état == marche et départ = 0 alors départ= rtc.now
Si état == arrêt et départ != 0 alors (le brûleur était en marche)
Temps_marche= rtc.now- départ
départ = 0 // réinit pour le prochain départ

Pour l’histoire des relais, si les deux sont activés en même temps, un bref moment, tu peux faire : avant d’actionner le relai ouverture, tu désactives le relai fermeture … et réciproquement … mais il faudrait trouver le problème à la source …

Quelle est la charge de ton programme hormis la régulation du chauffage … car s’il ne fait que ça, tu peux lui mettre des pauses pour le temps d’ouverture / fermeture et n’appeler la régulation que toutes les 2 minutes (mais pas de pause ici, c’est mieux)

Genre
If deltaT>5 alors
//action longue ouverture
le relai fermeture à Low// pour éviter que les 2 soient actifs
relai ouverture à High
Pause 5s
Relai ouverture à Low
Sinon si deltaT< 5 et delta T > 0 (si deltaT< 0 il faut faire autre chose …)
// action courte ouverture
Relai fermeture à Low
Relai ouverture à high
Pause 2s
Relai ouverture à Low …

salut, bon déjà je suis débutant et j’ai pas bien compris le fonctionnement des librairie pour le ds1307 j’utilise juste <RTClib.h> je sais pas s’il me faut time.h ,bref je suis un peu perdu encor.

Je viens d’essayer ça

 int depart;
 int fin;
  
  if((etat_bruleur == 1)&&(depart=0)){
    DateTime depart = RTC.now(); 
  }

    if((etat_bruleur == 0)&&(depart!=0)){
  tps_de_marche_bruleur = RTC.now - depart;
  }
 depart=0

ça ne fonctionne pas ,je comprend mal ce que tu veut dire ou j’ai pas déclarer quelque chose?

pour les pause relai (delay?) j’utilise un écran avec des bouton et c’est gênant. Je compte aussi utiliser un shiel Ethernet plus tard si j’y arrive.

je testerai demain de mettre un digitalWrite LOW comme tu as dit je n’y pas pensé.

j’avais teste différente façon de faire ces deux tempo et j’avais le problème d’un relai qui ce coupé plus quand la tempo etait sur 5 secondes on si la valeur de temperature de depar demander bouger en dehors de la différence de 5°.

Pour ta fonction de calcul de temps de marche ... elle est dans le loop ? dans une fonction spéciale ??

Si on reprend ton code ...
cette partie du code peut être dans le loop ou dans une fonction appelée assez rapidement ( pour la précision du temps de calcul)
il faut savoir que ce calcul te donne le temps de marche quand le bruleur est éteind et pas la durée cumulée sur la journée ... il faut voir ce que tu veux faire

unsigned long depart; // a mettre en début de programme (variable globale) 
int fin;                    // n'est plus utilisée ... donc on peut la virer
 
//memorise la date de mise en marche du bruleur
//si depart vaut 0, c'est que le bruleur était à l'arret juste avant
//une fois mis en marche, depart sera différent de zero et on n'entrera plus dans ce test
if((etat_bruleur == 1)&&(depart==0)){ //il faut mettre depart == 0 pour faire le test d'égalité
    depart = millis();        //utlise l'horloge du micocontroleur ... c'est suffisant
}

//calcule la durée de marche du bruleur (quand il s'arrête)
//etat_bruleur == 0signifie que le bruleur est à l'arret
//depart != 0 signifie que juste avant, le bruleur etait en marche
// donc les deux conditions réunies marquent la mise à l'arret du bruleur
// on calcule le temps de marche et on fixe depart à zero pour le prochain cycle
if((etat_bruleur == 0)&&(depart!=0)){ //etat_bruleur == 0 signifie qu'il est arreté
      tps_de_marche_bruleur = (millis() - depart) / 1000;  //le temp de marche est en secondes
      depart = 0;                   // on reset depart pour la prochaine mise en marche du bruleur ici
}

//on peut aussi faire comme ca pour avoir en direct le temps de marche du bruleur ...
//actualise le temps de marche quand le bruleur est en marche
if (depart != 0) tps_de_marche_bruleur = (millis() - depart) / 1000;  //le temp de marche en secondes

si les delay, même de 5 s sont génants ... utilise la méthode "blink without delay" ... mais il va faloir structurer un peu mieux ton code, et si tu veux qu'on t'aide, mets le en entrier ... car un extrait du code est insuffisant pour comprendre ...

bonjours ,j'ai pas encor fait de nouveau essai car j'ai reçu mon lcd tft 3,2" de chine et j'ai toujours pas réussi a le faire fonctionné ( Et-on obligé d'utiliser un shield pour le brancher a l'arduino ou peut-on brancher directement les fils de l’écran a l'arduino?)

je souhaite mesurer le temps de marche dans un premier temps puis calculer approximativement la conso de fioul en fonction du temps de fonctionnement du bruleur et je veut afficher un total sur l’écran en heure et litre voila

j'ai compris ton explication pour mesure le temps de marche je vais essayer des que j'ai 5minute.

Pour mes relais j’utilise déjà la méthode "blink without delay".

Mon code et en entier a télécharger dans mon premier post, il est trop long je ne peut pas le mettre sur la page.

Bonjour,

Attention, pour estimer la consommation de fioul, il ne faut pas mesurer le temps de marche du bruleur.
Il faut mesurer la durée d'excitation de l'électrovanne d'injection.
Il faut également connaître le diamètre de la buse et la pression donnée par la pompe pour en déduire le débit.

ha mince ça a l'aire plus compliqué que ce que je penser .

j'ai vu cette façon de calculer sur ce lien

https://blog.guiguiabloc.fr/index.php/2012/01/24/suivre-la-consommation-de-fioul-de-sa-chaudiere/

Donc tu pense que c'est faut?

Pour l’ecran, on est obligé de rien … tu dois pouvoir le cabler directement sur ta carte mais il y a un certain nombre de fils … donc autant d’erreurs possibles.

En attendant, tu peux faire tourner ton programme en surveillant les paramètres avec des serial.print … ca aide beaucoup !

j’ai vu ton code … il y a un truc qui va coincer à coup sur dans le bouton de menu (il n’y a qu’un bouton, donc tu passes les pages en boucle ?)
néanmoins
tu as un unsigned int selecteurPage (du coup il ne peut pas prendre de valeur négative)
et dans ton programme tu fais

 if (selecteurPage < 0) { 
  selecteurPage = 0;
 }

ca ne marchera pas … à ta place je ferais (en supposant que de la page 0 tu repasses à la page 9

etat_bp_menu = digitalRead(bp_menu);
  if ((etat_bp_menu != memoire_menu) && (etat_bp_menu == LOW)) {
    if (selecteurPage == 0) selecteurPage = 9;   //reboucle à la première page
    else if (selecteurPage > 0) selecteurPage--; //décrémente jusqu'à zero
  }
  memoire_menu = etat_bp_menu;

Ensuite pour ton calcul de durée de marche du bruleur, je l’intègrerai directement dans la fonction qui gère le bruleur, par exemple :

//en debut de programme
unsigned long depart;                  //date de mis en marche du bruleur
unsigned int cumul_marche_bruleur; //temps cumulé de marche du bruleur
unsigned long tps_de_marche_bruleur;   //temps de marche depuis le dernier allumage

void gestion_bruleur() {

  if (moyenne_sonde_chaudiere < valeur_demarage) {
    //allumage nécessaire.
    if (etat_bruleur == 0) { //le bruleur est eteint
        depart  = millis();     //date d'allumage
        digitalWrite(bruleur, HIGH);
        etat_bruleur = 1;
    }
  }
  else {
    
    if (moyenne_sonde_chaudiereA > valeur_coupure) {
      //exctinction du bruleur bruleur
      digitalWrite(bruleur, LOW);
      etat_bruleur = 0;
      cumul_marche_bruleur += tps_de_marche_bruleur; //on cumule ici le temps de marche
      depart = 0; // on reset le temps de marche

    }
  }
  if (depart != 0) tps_de_marche_bruleur = (millis() - depart)/1000; //durée de marche actualisée
}

tu fais déja tourner ton programme et ton installation (mis à part le LCD) ??

Non, ce n'est pas complètement faux puisqu'il parle bien de l'électrovanne.
par contre, où c'est faux, c'est que le débit du gicleur est donné pour une certaine pression, en général 7,5 bars.

Et le débit réel est proportionnel à la racine carrée de la pression.

Donc si D1 est le débit du gicleur à P1=7,5 bars (valeur marquée dessus) et P2 la pression donnée par ta pompe (la mienne est réglée à 10 bars) le débit réel D2 = racine(P2/P1) x D1.

Reste à connaître la pression donnée par ta pompe, perso j'ai acheté un manomètre pour vérifier, sinon la doc du bruleur doit donner cette valeur.

oui sa fonction sur le circuits radiateur depuis 4 jours et la sonde départ suit bien la valeur demander a 1° près.

après j'ai réussi a faire fonctionné le bruleur avec deux sondes sur la chaudière et c'est la que j'ai voulu que ma vanne soit plus rapide a baissé ou monté la température du coup j'ai essayer des faire fonctionner 5s pour quand la température remonte rapidement après le démarrage du bruleur.

le menu marche pas très bien effectivement il n'y a pas de bouton moins je n'avait pas réussi et je vien de comprendre pourquoi grâce a ta remarque.
Je n'avait pas chercher plus loin car c'est temporaire j'attendais l’écran tactile que j'ai reçu ce matin.
j'utilise déjà un écran 16x2.

Et je n'ai toujours pas réussi a le faire marcher rien ne s'allume (j'essaie avec une autre carte, une uno)

c'est cet écran :

j'ai brancher
arduino --> ecran

d0 a d7 --> db0 a db7
A2 --> RST
A3 --> CS
A4 --> WR
A5 --> RS

3.3V --> RD
5V --> VDD
GND --> GND

Ok bilbo83 je vais me renseigner sur ce que tu me dit et essayer de calcul sur papier déjà merci.

une photo de ma regulation

Chez DX ils ne sont pas très bavards sur les spécifications de ce qu'ils vendent... mais la ils parlent de tension de travail de 3,3V ... suis pas sur qu'il apprécie le 5V...

oui c'est ce que j'ai vu en relisant la page, tu pense qu'il est grillé?