contrôlant de température ,duree

Bonjour,

Mon fils m'a offert pour Noël un kit de découverte arduino afin que je m'initie à la programmation. Dans ce domaine je suis novice malgré que je fais de l'électronique depuis presque 40 ans .

Après quelques tentatives infructueuses, je désirais automatiser ma micro-brasserie avec votre aide si cela est possible ne sachant pas trop comment m'y prendre en particuliers au sujet des paliers de températures et de durées .
Je m'explique : je souhaite surveiller une température : quand la température de référence est atteinte, on enclenche un minuterie pendant un certain temps tout en contrôlant celle-ci. Quand la durée est écoulée on passe au second palier de température avec une nouvelle durée et cela au moins sur 4 cycles. Les 4 températures et durées sont différentes et sont stockées dans 8 variables différentes.

Je vous joints une base du code de mon programme très incomplet. Merci d'avance pour votre aide

Merci de bien vouloir détailler votre code s'il vous plait

#include <LiquidCrystal.h>              //on définie la librairie LCD

const int btn_ok = 7;     // on definie les broches des boutons ok et sel
const int btn_sel = 9;
const int btn_agmt_T = A0; //A0
const int btn_d_agmt_T = A1; //A1
const int btn_agmt_D = A2;
const int btn_d_agmt_D = A3;
const  int inputPin = A5;

int x = 1;
int etat_btn_ok = 0;         // on definie les états initiaux des boutons
int etat_btn_ok_ge = 0;
int etat_btn_sel = 0;
int etat_btn_agmt_T = 0;
int etat_btn_d_agmt_T = 0;
int etat_btn_agmt_D = 0;
int etat_btn_d_agmt_D = 0;
int selec_Prog = 0;
int Consigne_T = 0;
int Consigne_D = 0;
int VConsigne_T = 0;
int VConsigne_D = 0;
int Temperature_C_P1 = 0;
int Temperature_C_P2 = 0;
int Temperature_C_P3 = 0;
int Temperature_C_P4 = 0;
int Dure_C_P1 = 0;
int Dure_C_P2 = 0;
int Dure_C_P3 = 0;
int Dure_C_P4 = 0;
long previousTempo_1 = 0;
long intervalleTempo_1 = 1000;

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // on definie les broches du LCD


void setup()
{
  pinMode(btn_ok, INPUT);          //les boutons sont des entrées
  pinMode(btn_sel, INPUT);
  pinMode(btn_agmt_T, INPUT);
  pinMode(btn_d_agmt_T, INPUT);
  pinMode(btn_d_agmt_D, INPUT);
  pinMode(btn_d_agmt_D, INPUT);
  pinMode(inputPin, INPUT);
  lcd.begin(20, 4);                    //le LCD est un 20*4
  lcd.clear();
  Serial.begin(9600);
  lcd.setCursor(0, 0);
  lcd.print("bergerert");
  lcd.blink();
  delay (2000);
  lcd.noBlink();

}

void loop() {


  unsigned long Tempo_1 = millis ();
  if (Tempo_1 - previousTempo_1 > intervalleTempo_1) {
    previousTempo_1 = Tempo_1;
  }



  // prise en charge de la variabilité du voltage)
  selec_Prog = analogRead(inputPin);
  if (selec_Prog < 200 && selec_Prog >= 0) selec_Prog = 1;
  else if (selec_Prog < 500 && selec_Prog > 200) selec_Prog = 2; //Premier Pallier
  else if (selec_Prog < 700 && selec_Prog > 505) selec_Prog = 3; //
  else if (selec_Prog < 800 && selec_Prog > 705) selec_Prog = 4;  //
  else if (selec_Prog < 1200 && selec_Prog > 810) selec_Prog = 5; //Depart


  if (selec_Prog == 1) {
    Depart();
  /*  
     je souhaite surveiller une température  : 
     quand la température de référence est atteinte, 
     on enclenche un minuterie pendant un certain temps tout en contrôlant celle-ci. 
     Quand la durée est écoulée on passe au second palier de température avec une nouvelle durée et cela  au moins sur  4 cycles.  
     Les 4 températures et durées sont différentes et  sont stockées dans  8 variables différentes.
 */ 
lcd.setCursor(2, 0);
  lcd.print("Pallier");// 1 pui 2 pui 3 pui 4 
  lcd.setCursor(0, 1);
  lcd.print("temperature");
  lcd.setCursor(0, 2);
  lcd.print ((char)223);//Affiche le caractère °(degrés)
  lcd.setCursor(13, 1);
  lcd.print("duree restent"); //duree - 1mm -1mm -1mm
 
 
 
  }

  if (selec_Prog == 2) {
    PremierPallier();
    validation();
    Temperature_C_P1 = VConsigne_T;
    Dure_C_P1 = VConsigne_D;
    D_Agmt_Dure();
    D_Agmt_T();
  }

  if (selec_Prog == 3) {
    DeuxiemePallier();
    validation();
    Temperature_C_P1 = VConsigne_T;
    Dure_C_P1 = VConsigne_D;
    D_Agmt_Dure();
    D_Agmt_T();
  }

  if (selec_Prog == 4) {
    TroisiemePallier();
    validation();
    Temperature_C_P1 = VConsigne_T;
    Dure_C_P1 = VConsigne_D;
    D_Agmt_Dure();
    D_Agmt_T();
  }

  if (selec_Prog == 5) {
    QuatriemePallier();
    validation();
    Temperature_C_P1 = VConsigne_T;
    Dure_C_P1 = VConsigne_D;
    D_Agmt_Dure();
    D_Agmt_T();
  }

}


void Depart() {
  // lcd.clear();
  lcd.setCursor(10, 2);
  lcd.print("Depart");
  delay (200);
  lcd.clear();
}


void PremierPallier() {

  lcd.setCursor(2, 0);
  lcd.print("Premier Pallier");
  lcd.setCursor(0, 1);
  lcd.print("temperature");
  lcd.setCursor(13, 1);
  lcd.print("duree");
  lcd.setCursor(0, 2);
  lcd.print("consi  ");
  lcd.print(Temperature_C_P1);
  lcd.print ((char)223);//Affiche le caractère °(degrés)
  lcd.setCursor(13, 2);
  lcd.print(Dure_C_P1);
  lcd.print("mm");
  lcd.setCursor(0, 3);
  lcd.print(" rel ");
  lcd.print(Consigne_T);
  lcd.print ((char)223);//Affiche le caractère °(degrés)
  lcd.setCursor(13, 3);
  lcd.print(Consigne_D);
  lcd.print("mm");


}
void DeuxiemePallier() {

  lcd.setCursor(2, 0);
  lcd.print("DeuxiemePallier");
  lcd.setCursor(0, 1);
  lcd.print("temperature");
  lcd.setCursor(13, 1);
  lcd.print("duree");
  lcd.setCursor(0, 2);
  lcd.print("consi  ");
  lcd.print(Temperature_C_P2);
  lcd.print ((char)223);//Affiche le caractère °(degrés)
  lcd.setCursor(13, 2);
  lcd.print(Dure_C_P2);
  lcd.print("mm");
  lcd.setCursor(0, 3);
  lcd.print(" rel ");
  lcd.print(Consigne_T);
  lcd.print ((char)223);//Affiche le caractère °(degrés)
  lcd.setCursor(13, 3);
  lcd.print(Consigne_D);
  lcd.print("mm");

}

void TroisiemePallier() {

  lcd.setCursor(2, 0);
  lcd.print("TroisiemePallier");
  lcd.setCursor(0, 1);
  lcd.print("temperature");
  lcd.setCursor(13, 1);
  lcd.print("duree");
  lcd.setCursor(0, 2);
  lcd.print("consi  ");
  lcd.print(Temperature_C_P3);
  lcd.print ((char)223);//Affiche le caractère °(degrés)
  lcd.setCursor(13, 2);
  lcd.print(Dure_C_P3);
  lcd.print("mm");
  lcd.setCursor(0, 3);
  lcd.print(" rel ");
  lcd.print(Consigne_T);
  lcd.print ((char)223);//Affiche le caractère °(degrés)
  lcd.setCursor(13, 3);
  lcd.print(Consigne_D);
  lcd.print("mm");

}

void QuatriemePallier() {
  lcd.setCursor(2, 0);
  lcd.print("QuatriemePallier");
  lcd.setCursor(0, 1);
  lcd.print("temperature");
  lcd.setCursor(13, 1);
  lcd.print("duree");
  lcd.setCursor(0, 2);
  lcd.print("consi  ");
  lcd.print(Temperature_C_P4);
  lcd.print ((char)223);//Affiche le caractère °(degrés)
  lcd.setCursor(13, 2);
  lcd.print(Dure_C_P4);
  lcd.print("mm");
  lcd.setCursor(0, 3);
  lcd.print(" rel ");
  lcd.print(Consigne_T);
  lcd.print ((char)223);//Affiche le caractère °(degrés)
  lcd.setCursor(13, 3);
  lcd.print(Consigne_D);
  lcd.print("mm");

}
void validation()
{
  etat_btn_ok = digitalRead(btn_ok);      //on lit l'état du bouton ok
  if (etat_btn_ok == HIGH)
  {
    VConsigne_D = Consigne_D;
    VConsigne_T = Consigne_T;
  }
}



void D_Agmt_T()
{

  etat_btn_agmt_T = digitalRead(btn_agmt_T);   //on lit l'état du bouton sel

  if (etat_btn_agmt_T == HIGH) {
    // et on affiche son état
    Consigne_T++;      //on incremente le comptage
    delay (200);
  }


  etat_btn_d_agmt_T = digitalRead(btn_d_agmt_T);   //on lit l'état du bouton sel
  if (etat_btn_d_agmt_T == HIGH) {
    // et on affiche son état
    Consigne_T--;
    delay (200);
    if (Consigne_T == 9) {
      lcd.setCursor(9, 2);
      lcd.print("   ");
      lcd.setCursor(7, 3);
      lcd.print("   ");
    }
    if (Consigne_T <= 0) {
      Consigne_T = 0;
    }
  }
}
void D_Agmt_Dure()
{

  etat_btn_agmt_D = digitalRead(btn_agmt_D);   //on lit l'état du bouton sel

  if (etat_btn_agmt_D == HIGH) {
    // et on affiche son état
    Consigne_D++;      //on incremente le comptage
    delay (200);
  }

  etat_btn_d_agmt_D = digitalRead(btn_d_agmt_D);   //on lit l'état du bouton sel
  if (etat_btn_d_agmt_D == HIGH) {
    // et on affiche son état
    Consigne_D--;
    delay (200);

    if (Consigne_D <= 9) {
      lcd.setCursor(15, 2);
      lcd.print("   ");
      lcd.setCursor(15, 3);
      lcd.print("   ");
    }
    if (Consigne_D <= 0) {
      Consigne_D = 0;
    }
  }
}

Salut,

Je connais pas mal ce genre de problématique, je te conseille de reprendre ton architecture pour faire quelque chose comme ça :

void loop() {

gestionRegulation();
gestionAffichage();

}


void gestionRegulation {

switch(step) {

case 0: // repos

if(digitalRead(boutonStart)==LOW)  {

step++;
start = millis();
tempDepart = getTemp();

}

break;

case 1: //rampe à 5°C /min

consigne = tempDepart + (millis()-start)/60000.0 * 5;
setTemp(consigne); 

if(consigne>=tempPalier) {

step++;
start=millis()

}

break;

case 2:

if(millis()>=start+ dureePalier) {

step++;
start=millis()

}

break;

...

}

}

void gestionAffichage() {

static unsigned long refresh;

if(millis()>refresh+200) { //permet de ne pas rafraichir trop souvent pour garder en réactivité

refresh=millis();

switch(step) {

case 0:
lcd.print( "   "  );
...
break;

case 1:
lcd.print( "   "  );
...
break;

case 2:
lcd.print( "   "  );
...
break;

}

}
}

Après j'ai pas recollé avec ton code mais tu dois pouvoir saisir comment l'adapter :wink:

Bonjour

Merci d'avoir pris le temps de me répondre
étant complètement débutant je ne comprends pas où vous voulez en venir avec votre morceau de code.
Ce que j'ai concocté je l'ai récupéré de droite et de gauche sur le net

Merci de bien vouloir détailler votre code s'il vous plait

En gros ce que décrit B@tto c'est la façon de structurer un programme en écrivant les fonctions en dehors de la boucle et de les appeler ensuite dans la boucle.

                                 // déclaration de la fonction

tut_tut ()                             // nom de la fonction  >>  tut_tut

{                                        // ouvre l'accolade dans laquelle se trouve l'action de la fonction

Mets un coup de claxon  ;     // action

{                                        // ferme l'accolade dans laquelle se trouve l'action de la fonction
 
                                 // fin de déclaration


                           // début de boucle principale

void loo()  
{

tut_tut();                             // appelle la fonction


}

                           // fin de boucle principale

bonjour

merci pour cette explication, je vais l'expérimenter

Est ce que vous auriez une idée sur le problème que j'avais soumis, à savoir comment gérer mes problèmes des paliers de température et leurs durées

Merci pour vos conseils et si vous avez d'autres idées, je suis preneur
détailler votre code s'il vous plait

En utilisant la fonction millis(), tu définis autant de variables que tu auras de pallier.

Ces variables contiennent le temps en milliseconde du début du pallier depuis le début du programme.

lors du dernier pallier tu remets le compteur à 0.

http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.Millis

http://www.areaprog.com/arduino/article-629-millis-et-micros-utilisation-des-fonctions-millis-et-micros-pour-tirer-profit-de-l-horloge-interne-de-l-arduino

bonjour

J'ai beaucoup de mal a assemblées ensemble les différentes variable de température et de duree de mes pallier
pourriez-vous m'écrire ces quelques lignes de code svp
détailler votre code s'il vous plait
je suis novice
merci

unsigned long currentMillis = millis ()/1000; 
int Temperature_C_P1 = 28 // 28 degré 
int Temperature_C_P2 = 35 // 35 degré 
int Temperature_C_P3 = 65 // 65 degré 
int Temperature_C_P4 = 73 // 73 degré 
int Dure_C_P1 = 0;10000 ;  //10minute
int Dure_C_P2 = 0;20000;  //20minute
int Dure_C_P3 = 0;110000;  //1 heur 10
int Dure_C_P4 = 0;5000; 5minute

void setup(){

}

void loop() {

}

Si tu es novice commences par les bases

Si mon code te perds, ça veut dire que tu ne maitrises pas les bases : boucle, conditions, fonctions ... Parce que la c'est bien gentil de nous mettre un setup() et un loop() vide ...

+1 avec B@tto...

Lire, comprendre, essayer....

Bref...

On a une mesure de temps qui est une corde qui se déroule.
On se dit " j'aimerais qu'il se passe un truc à 5 mètre".
Sur la corde on mets un bout de laine rouge..... on mesure la corde qui défile.
A 5 mètres il se passe notre truc mais on continue à mesurer parce qu'on a décidé qu'à 7,5 mètres il va se passer un autre truc-machin.
A 7,5 mètres, il se passe le truc-machin et on décide de revenir à 0 pour que le premier pallier se refasse.
Alors on enlève la laine rouge (faut courir vite :grin: ) on remet le bout de laine à 7,5 mètre et on se dit voilà c'est mon nouveau point 0 et on re-mesure 5 m puis 7,5 m etc, etc.

millis() est la corde qui se déroule, cette fonction additionne les millisecondes qui passent, ce nombre augmente pendant ~49 jours puis revient à 0 ( même une corde à une fin...).

Tu définis une variable à laquelle tu donne la valeur de millis() :

long laine_rouge ;

long Pallier = les millisecondes du pallier;

loop()
{
laine_rouge = millis() ;

if (millis() - laine_rouge >= pallier)
.....
}

Je te laisse prospecter.... :grinning: