Discussion :

[hoturi]

Bonjour

J'aimerais me construire ma pico brasserie et faire en sorte que celle-ci soit le plus automatisé possible, je voulais savoir si cela été possible avec un système de type Arduino relié par un un ordinateur et contrôler à l'aide d'oracle.
Si cela est possible y'a t-il des experts qui pourrait m'aider j'ai des connaissances de base en JAVA et je voudrais les approfondir avec ce projet.

Merci d'avance

Voici le schéma de la pico brasserie :


Voici le programme que je dois creer pour aller avec :

Déroulement du programme :

I. Démarrage du Programme (empattage du malt)

1. Allumer pompe 1
2. Allumer thermo1 -----------> maintenir à 51°C (allumer éteindre thermo1)
3. Cuve 2 atteint 50°C --------> alarme pour prévenir qu’il faut ajouter le malt dans la cuve 2
4. Allumage moteur 1 --------> brassage du malt

II. Control de la température (mix)

5. Pallier de température cuve 1 :
• 51°C / 30min
• 64°C /demander le temps à l’utilisateur (pallier 1)
• 69°C / demander le temps à l’utilisateur (pallier 2)
• 72°C / demander le temps à l’utilisateur (pallier 3)
• 80°C / maintenir
Pour maintenir la température pendant les paliers allume ou éteindre le thermo1.

6. Pallier de température cuve 1 :
• 50°C / 30min
• 62-63°C /demander le temps à l’utilisateur (pallier 1)
• 66-68°C / demander le temps à l’utilisateur (pallier 2)
• 70°C / demander le temps à l’utilisateur (pallier 3)
Pour maintenir la température pendant les paliers allume ou éteindre la pompe 1.

III. Rinçage et filtration vers cuve 3

7. Ouvrir vanne 2 et lancer pompe2 (pendant 15 min)
8. Ouvrir vanne 1 et éteindre thermo1
9. Ouvrir vanne 2 et lancer pompe2 (pendant 15 min)
10. Arrêter pompe2 et fermer vannes2

IV. Ebullition
11. Allumer thermo2 atteindre 102°C et maintenir pendant 1h30
12. Lorsque 100°C activer moteur 2 (descendre le houblon 1), le remonter après 60 min
13. Lorsque 1h10 atteint activer moteur 3 (descendre le houblon 2), le remonter après 30 min
14. Eteindre le thermo2 après 1h30 -----------> lancer alarme fin du programme

[Auteur]

Bonsoir,

si je récapitule ton système tu as besoin :
Côté matériel

• en sortie :
  
  • TTL (on/off):
    - de piloter 2 électrovannes (ouverte / fermée) ;
    - de piloter 2 pompes (ouverte / fermée) ;
    - de piloter 2 thermo-plongeurs (chauffage oui / non)
    - alarme (on/off)
  • Analogiques
    - de piloter 3 moteurs (vitesse de rotation variable);
• en entrée analogique
  - de lire 3 sondes de températures.

Arduino sait très bien faire du on/off mais il est hors de question de brancher une électrovanne directement sur une sortie TTL de la platine (quelle que soit la carte).
Pour les moteurs, j'ai admis que la vitesse de rotation était variable : il existe des shields qui permettent de piloter 2 moteurs (shield motor) mais nécessitent 2 sorties TTL et 2 sorties PWM (1 TTL et 1 PWM par moteur). Donc pour 3 moteurs, 3 TTL et 3 PWM.
Rien que pour ce matériel, tu as besoin donc de 10 sorties TTL et 3 sorties PWM.

Et 3 entrées analogiques pour tes sondes.

Donc a priori, avec, par exemple, un Arduino Uno avec ses 14 sorties TTL et ses 6 entrées analogiques pourrait faire l'affaire mais tu vas devoir sortir le fer à souder .


Côté logiciel.
- Quel type de régulation veux-tu appliquer P, PI, PID ?
- L'IDE Arduino est plutôt orienté C/C++ que Java. Mais une fois programmé rien ne t'empêche de créer une application Java qui va lire ou écrire sur le port de l'Arduino.



Donc je dirais oui, ton projet est réalisable avec un Arduino. Mais, je me pose des questions :
- pour la régulation est-ce que le micro-contrôleur sera assez réactif (temps de calculs) ?
- le programme risque d'être assez volumineux, est-ce l'Arduino a assez de mémoire ?

[hoturi]

Merci de ta réponse je ne peux donc pas utiliser des électrovannes si je comprend bien. Pour la régulation de la température je dois garder dans ma cuve 2 trois paliers différents pendant un temps que choisi l'utilisateur à savoir :

- 50-52°C
- 62-63°C
- 66-68°C

Je ne sais pas ce qui est le mieux, en faite je pensais récupérer les calories dans la cuve 1 pour les transférer dans la cuve 2 par un système de serpentin en inox, ce qui a l'avantage de mieux contrôler la température de la cuve 2 et d'éviter de brûler mon malt sur le thermoplongeur donc je ne sais pas ce qui est le mieux en P, PI ou PID.

Je pense commencer par juste effectuer la partie avec la cuve 1 et 2, à savoir la régulation de la température, je supprime les électrovannes.

Je ne connais pas C/C++ je suis débutant en JAVA juste des bases, j'ai vraiment envie d'apprendre et de lancer ce projet, je pense acheter une carte avec une sonde et un SSR afin de faire des tests genre allumer une lampe si la température est en dessous d'un certain seuil pensé vous que cela soit envisageable pour un novice?

Faut il que je me lance sous arduino ou bien un autre type de carte genre RasberyPi?

[Auteur]

je ne peux donc pas utiliser des électrovannes si je comprend bien.

si, mais pas directement. Je vais être plus précis : tu ne peux pas brancher sur un micro-contrôleur des composants qui demandent de la puissance : électrovanne, moteur, résistance chauffante, etc. Tu es obligé de passer par des interfaces. Pour le moteur je t'ai donné l'exemple du shield moteur : il est constitué d'un pont en H que tu dois alimenter avec une source externe. L'Arduino fournit les commandes à ce pont pour piloter le moteur (vitesse et sens de rotation). Pour l'électrovanne tu peux utiliser un petit optocoupleur la commande étant sur l'Arduino (et en n'oubliant pas la diode de roue libre sur l'électrovanne !!).


Si tu es débutant, commence plutôt par un projet moins important. Donc effectivement tu peux lire la température d'un liquide et en fonction de celle-ci allumer une LED. Mais quel est ton niveau en électronique ?

[hoturi]

Mais quel est ton niveau en électronique ?

Un niveau plutôt très débutant disons que je répare mes ordi portables en soudant dessoudant les composant qui sont HS sur les cartes mère type port USB Jack power,... Mais je n'ai aucune connaissance en électronique ce n'est absolument pas mon domaine, je souhaite apprendre afin de bidouiller dans mon coin.

Je sais aussi que si je ne me fixe pas un but je ne ferais rien, la pico-brasserie me semblait un bon objectif.

Je vais commencer juste par tenter de réguler la température dans la cuve 1 et 2 cela sera pas mal :

1 allumer éteindre le thermoplongeur en fonction d'une température pendant un temps déterminé dans la cuve 1.
2 activer la pompe pour récupérer les calories de la cuve 1 afin de chauffer la cuve 2 à des pallier de températures déterminé.
3 déclencher une alarme lorsque le séquences de température est terminé.

Cela semble plus abordable?

[cedd70]

Plus que réalisable pour pas trop chers
Je verrais bien une petite sonde de température genre pt100 sur l'entrée analogique de l'aduino
Un relais pour commander ta résistance
Et des shilds PWM pour commander en vitesse t'es moteurs
Le tout sur Arduino

[Auteur]

Un niveau plutôt très débutant disons que je répare mes ordi portables en soudant dessoudant les composant qui sont HS sur les cartes mère type port USB Jack power,... Mais je n'ai aucune connaissance en électronique ce n'est absolument pas mon domaine, je souhaite apprendre afin de bidouiller dans mon coin.

tu sais identifier les composants autrement que par leurs numéros de série ? Sais-tu réaliser des petits montages (astable, monostable, utiliser des portes logiques, par exemple). Je pense qu'il faut que tu en apprennes un minimum en électronique avant de te lancer dans ce projet.

1 allumer éteindre le thermoplongeur en fonction d'une température pendant un temps déterminé dans la cuve 1.
2 activer la pompe pour récupérer les calories de la cuve 1 afin de chauffer la cuve 2 à des pallier de températures déterminé.
3 déclencher une alarme lorsque le séquences de température est terminé.

Cela semble plus abordable?

oui et non. Je pense que pour programmer l'Arduino, il n'y aura pas trop de soucis. Ce qui m'ennuie ce sont des connaissances en électronique qui sont trop limitées car comme je l'ai déjà indiqué tu ne peux pas brancher des composants de puissance directement sur l'Arduino.

Ce que tu peux faire c'est utiliser des LED pour simuler le fonctionnement des pompes, thermoplongeurs et alarme.

[hoturi]

tu sais identifier les composants autrement que par leurs numéros de série ? Sais-tu réaliser des petits montages (astable, monostable, utiliser des portes logiques, par exemple). Je pense qu'il faut que tu en apprennes un minimum en électronique avant de te lancer dans ce projet.



oui et non. Je pense que pour programmer l'Arduino, il n'y aura pas trop de soucis. Ce qui m'ennuie ce sont des connaissances en électronique qui sont trop limitées car comme je l'ai déjà indiqué tu ne peux pas brancher des composants de puissance directement sur l'Arduino.

Ce que tu peux faire c'est utiliser des LED pour simuler le fonctionnement des pompes, thermoplongeurs et alarme.

Ok je vais commencer par cela et ensuite évoluer vers du matériel plus lourd. Je vais regarder des tutoriels pour faire cela merci.

Je voulais savoir l'arduino exécute le code indépendamment de l'ordinateur il n'est pas un simple relais qui permet de faire le pont entre un ordinateur et des sondes par exemple, c'est pour cela que si le programme créer est trop important l'arduino ne peux l’exécuter. Dans ce cas ne serait il pas plus simple d’utiliser une carte qui ne fait que l’acquisition et qui commande différentes sorties?

[Auteur]

L'arduino une fois programmé est complètement autonome mais il ne peut rien stocker. Après il est tout à fait possible qu'il transmette via le port USB (regarde les fonctions serial) les données reçues.

[hoturi]

Bon j'ai enfin réussi a prendre le temps de commander un kit arduino des sondes des cables,...
Pour l'instant je commence a bidouiller.
J'ai réussi a monter 2 sondes DS18B20 qui prennent la température.

Mon but dans un premier temps et de mesurer la température dans la cuve 1 et 2.

Ensuite j'allume un relais (pour l'instant une diode) en fonction d'une température que j'aurais défini.

En gros dans la cuve 1 je veux une température de 80°C max.

Dans la cuve 2 je veux :
- 30 min à 60-63°C
- 45 min 65-67°C
- 15 min 70°C


Pouvez vous m'aider a réaliser mon code?

Voici ce que j'ai pour l'instant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#include <stdio.h>
#include <string.h>
#include <OneWire.h>
 
#define NBRE_CAPTEUR 2 // nombre de capteur sur l'arduino
 
// *********** declararation des variables gestion des capteurs de temperature  *******************
typedef struct Temperature Temperature;
struct Temperature
{
  float valeur;         // temperature en Celsius, 1 chiffre apres la virgule
  byte addr[8];         // identifiant capteur
  int pin;          // numero de pin a utiliser
  char mnemo[32];         // mnemonique de la variable
};
 
Temperature temperature[NBRE_CAPTEUR];    //creation des instances
 
// *********** fin declararation des variables gestion des capteurs de temperature  *******************
 
 
void setup(){
 
        Serial.begin(9600);       // initialisation de la liaison serie
 
 
// *********** initialisation des variables gestion des capteurs de temperature  *******************
 
 
  temperature[0].addr[0]= 0x28; // capteur rouge
  temperature[0].addr[1]= 0xFF;
  temperature[0].addr[2]= 0x46;
  temperature[0].addr[3]= 0xE5;
  temperature[0].addr[4]= 0x91;
  temperature[0].addr[5]= 0x15;
  temperature[0].addr[6]= 0x04;
  temperature[0].addr[7]= 0x04;
  temperature[0].pin=7;
  temperature[0].valeur=0;      // temperature en °C, 1 chiffre apres la virgule
        strcpy(temperature[0].mnemo,"temperature chauffage");  // ex: salon
 
  temperature[1].addr[0]= 0x28; // capteur rouge
  temperature[1].addr[1]= 0xFF;
  temperature[1].addr[2]= 0xF5;
  temperature[1].addr[3]= 0xD4;
  temperature[1].addr[4]= 0x61;
  temperature[1].addr[5]= 0x15;
  temperature[1].addr[6]= 0x01;
  temperature[1].addr[7]= 0x70;
  temperature[1].pin=8;
  temperature[1].valeur=1;      // temperature en °C, 1 chiffre apres la virgule
        strcpy(temperature[1].mnemo,"temperature moult");  // ex: salon
 
 
 
}
 
void loop(){
 
 
gestion_temperature();
 
delay(5000);
 
}
 
 
void gestion_temperature()
{
 
/********************************************************************************
  Cette fonction permet d'interroger tous les capteurs de temperature OneWire
  qui ont ete declare dans "temperature[i]"
********************************************************************************/
 
  byte i=0;
 
  for(i=0; i<NBRE_CAPTEUR; i++){
 
    Serial.print(temperature[i].mnemo);
    Serial.print(" => ");
    temperature[i].valeur =getStuff(temperature[i].addr,temperature[i].pin);
    Serial.print(temperature[i].valeur);
    Serial.println(" C ");
    delay(100);
 
  }
 
}
 
 
float getStuff(byte addr[8], int pin) // indiquer le n? de pin ? utiliser
{
 
/********************************************************************************
  Cette fonction permet d'interroger le capteur de temperature OneWire
  qui a ?t? d?clar? dans "temperature[i]"
********************************************************************************/
 
  OneWire  ds(pin);  // creation d'un objet OneWire avec le bon n? de pin
 
  byte i;
  byte present = 0;
  byte data[12];
 
  float real_temp;
  float temp_count;
  float read_temp;
 
// Fonction recherche d?sactiv?e car non utilis?e
/*if ( !ds.search(addr)) {
      Serial.print("No more addresses.\n");
      ds.reset_search();
}
 
 
  Serial.print("R=");
  for( i = 0; i < 8; i++) {
    Serial.print(addr[i], HEX);
    Serial.print(" ");
  }
 
  if ( OneWire::crc8( addr, 7) != addr[7]) {
    Serial.print("CRC is not valid!\n");
    return 998;
  }
  
  if ( addr[0] != 0x10) {
    Serial.print("Device is not a DS18S20 family device.\n");
    return 999;
  }
*/
  ds.reset();
  ds.select(addr);
  ds.write(0x44,1); // start conversion, with parasite power off at the end (1=parasite mode)
 
  delay(5000);     // delay de 1s si mode parasite. 100ms en mode normal
  // we might do a ds.depower() here, but the reset will take care of it.
 
  present = ds.reset();
  ds.select(addr);    
  ds.write(0xBE);         // Read Scratchpad
 
 
    for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
  }
 
  read_temp=((data[1]<<8) | data[0]) >> 1 ;            // Divide the temperature by 2
  temp_count=float(data[7] - data[6])/(float)data[7];  // Convert to real temperature
  real_temp = ((float)read_temp-0.25)+temp_count;
 
  // arrondi 1 chiffre apres la virgule
  int temp = real_temp*10;
  real_temp = (float)temp/100;
 
  // Serial.println();
 
  return real_temp;
}

Merci d'avance.

[hoturi]

petite avancé dans mon code

J'allume une diode en fonction d'une température il me faut trouver comment maintenir pendant un temps déterminé.

Je pense avoir besoin des experts du site :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#include <stdio.h>
#include <string.h>
#include <OneWire.h>
 
#define NBRE_CAPTEUR 2 // nombre de capteur sur l'arduino
 
// *********** declararation des variables gestion des capteurs de temperature  *******************
typedef struct Temperature Temperature;
struct Temperature
{
  float valeur;         // temperature en Celsius, 1 chiffre apres la virgule
  byte addr[8];         // identifiant capteur
  int pin;          // numero de pin a utiliser
  char mnemo[32];         // mnemonique de la variable
};
 
Temperature temperature[NBRE_CAPTEUR];    //creation des instances
 
// *********** fin declararation des variables gestion des capteurs de temperature  *******************
 
 
void setup(){
 
        Serial.begin(9600);       // initialisation de la liaison serie
 
 
// *********** initialisation des variables gestion des capteurs de temperature  *******************
 
 
  temperature[0].addr[0]= 0x28; // capteur rouge
  temperature[0].addr[1]= 0xFF;
  temperature[0].addr[2]= 0x46;
  temperature[0].addr[3]= 0xE5;
  temperature[0].addr[4]= 0x91;
  temperature[0].addr[5]= 0x15;
  temperature[0].addr[6]= 0x04;
  temperature[0].addr[7]= 0x04;
  temperature[0].pin=7;
  temperature[0].valeur=0;      // temperature en °C, 1 chiffre apres la virgule
        strcpy(temperature[0].mnemo,"temperature chauffage");  // ex: salon
 
  temperature[1].addr[0]= 0x28; // capteur vert
  temperature[1].addr[1]= 0xFF;
  temperature[1].addr[2]= 0xF5;
  temperature[1].addr[3]= 0xD4;
  temperature[1].addr[4]= 0x61;
  temperature[1].addr[5]= 0x15;
  temperature[1].addr[6]= 0x01;
  temperature[1].addr[7]= 0x70;
  temperature[1].pin=8;
  temperature[1].valeur=1;      // temperature en °C, 1 chiffre apres la virgule
        strcpy(temperature[1].mnemo,"temperature moult");  // ex: salon
 
pinMode (9,OUTPUT);// broche 10 configurée en sortie
pinMode (10,OUTPUT);// broche 10 configurée en sortie
 
 
}
 
/********************************************************************************
  Cette fonction permet d'allumer et d'éteindre une diode en focntion d'une
  température choisi.
********************************************************************************/
 
void loop(){
 
 
gestion_temperature();
 
delay(5000);
 
if (  temperature[0].valeur > 10)
{digitalWrite(9,HIGH); // alluler la led du capteur rouge
}
else {digitalWrite(9,LOW);}
 
if (  temperature[1].valeur > 20)
{digitalWrite(10,HIGH); // alluler la led capteur vert                       
}
else {digitalWrite(10,LOW);}
}
 
 
 
/********************************************************************************
  Cette fonction permet d'interroger tous les capteurs de temperature OneWire
  qui ont ete declare dans "temperature[i]"
********************************************************************************/
 
 
 
void gestion_temperature()
{
  byte i=0;
 
  for(i=0; i<NBRE_CAPTEUR; i++){
 
    Serial.print(temperature[i].mnemo);
    Serial.print(" => ");
    temperature[i].valeur =getStuff(temperature[i].addr,temperature[i].pin);
    Serial.print(temperature[i].valeur);
    Serial.println(" C ");
    delay(100);
  }
 
}
 
/********************************************************************************
  Cette fonction permet d'interroger le capteur de temperature OneWire
  qui a ?t? d?clar? dans "temperature[i]"
********************************************************************************/
float getStuff(byte addr[8], int pin) // indiquer le n? de pin ? utiliser
{
 
  OneWire  ds(pin);  // creation d'un objet OneWire avec le bon n? de pin
 
  byte i;
  byte present = 0;
  byte data[12];
 
  float real_temp;
  float temp_count;
  float read_temp;
 
 
  ds.reset();
  ds.select(addr);
  ds.write(0x44,1); // start conversion, with parasite power off at the end (1=parasite mode)
 
  delay(5000);     // delay de 1s si mode parasite. 100ms en mode normal
  // we might do a ds.depower() here, but the reset will take care of it.
 
  present = ds.reset();
  ds.select(addr);    
  ds.write(0xBE);         // Read Scratchpad
 
 
    for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
  }
 
  read_temp=((data[1]<<8) | data[0]) >> 1 ;            // Divide the temperature by 2
  temp_count=float(data[7] - data[6])/(float)data[7];  // Convert to real temperature
  real_temp = ((float)read_temp-0.25)+temp_count;
 
  // arrondi 1 chiffre apres la virgule
  int temp = real_temp*10;
  real_temp = (float)temp/100;
 
  // Serial.println();
 
  return real_temp;
}

[f-leb]

Bonjour,

Tu peux programmer ça sous forme de machine à états (Finite State machine).

Pour une régulation automatique de chauffage toute simple en tout ou rien cela donnerait quelque chose comme (c'est très simplifié, une cuve avec un fonctionnement avec hystérésis qui fait osciller la température autour de 80°C) :

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
etat_cuve1=1;
consigne_cuve1 = 80;  // température consigne=80°C
hyst_cuve1 = 2;  //  hysteresis, plus ou moins 2°C autour de la consigne
 
void loop() {
 
 switch (etat_cuve1)
  {
    case 1:
        chauffage_cuve1(ON);
        if (temp_cuve1() > consigne_cuve1+hyst_cuve1) etat_cuve1=2;
        break;
 
    case 2:
        chauffage_cuve1(OFF);
        if (temp_cuve1() < consigne_cuve1-hyst_cuve1) etat_cuve1=1;
        break;
  }
 
delay (30000) ; // pause 30s
}

Maintenant tu as 3 cuves avec des contraintes de temps pour gérer les cycles.
Tu peux jouer avec la fonction millis() pour gérer le temps, mais tout ton cycle est perdu en cas de coupure. Ne faudrait-il pas une vraie horloge temps réel pour gérer ton cycle ?

La question qu'on peut se poser avec un cycle assez complexe avec 3 cuves, c'est si tout ça va rentrer dans une 'tite Arduino Uno

[hoturi]

Merci pour votre code on m'a aussi conseiller d'utiliser une bibliothèque (simpleMinuteur) qui beaucoup plus simple d'utilisation.
Le schéma en haut est pour un système de rêve mais pour l'instant je vais me contenter de 2 sondes et 2 relais.

Je fais monter la température à 80°C dans une cuve et l'autre je fais des paliers

En ce qui concerne en cas de coupure de courant avec ou sans horloge cela aura un impact car si je casse un palier de temps, avant de faire remonter la température il y aura des modifications de la qualité de la bière (en bien ou en mal).

Merci pour votre aide je vais regarder votre code mais vu mon niveau cela va me prendre du temps.

[hoturi]

Bonjour

J'ai un peu avancé en allant chercher des exemples de codes à droite à gauche mais je reste bloqué sur cette problématique des paliers, voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
#include <stdio.h>
#include <string.h>
#include <OneWire.h>
#include <simpleMinuteur.h>
#define NBRE_CAPTEUR 2 // nombre de capteur sur l'arduino
 
// *********** declararation des variables gestion des capteurs de temperature  *******************
typedef struct Temperature Temperature;
struct Temperature
{
  float valeur;         // temperature en Celsius, 1 chiffre apres la virgule
  byte addr[8];         // identifiant capteur
  int pin;          // numero de pin a utiliser
  char mnemo[32];         // mnemonique de la variable
};
 
Temperature temperature[NBRE_CAPTEUR];    //creation des instances
 
// *********** declaration des variables gestion des paliers de temps  ******************************************
 
 
boolean verrouPalier1 = false;
boolean verrouPalier3 = false;
int palierEnCours = 0;
 
simpleMinuteur palier1;
simpleMinuteur palier3;
 
// *********** FIN declaration des variables  *********************************************************************
 
 
void setup(){
 
        Serial.begin(9600);       // initialisation de la liaison serie
 
 
// *********** initialisation des variables gestion des capteurs de temperature  *******************
 
 
  temperature[0].addr[0]= 0x28; // capteur rouge
  temperature[0].addr[1]= 0xFF;
  temperature[0].addr[2]= 0x46;
  temperature[0].addr[3]= 0xE5;
  temperature[0].addr[4]= 0x91;
  temperature[0].addr[5]= 0x15;
  temperature[0].addr[6]= 0x04;
  temperature[0].addr[7]= 0x04;
  temperature[0].pin=7;
  temperature[0].valeur=0;      // temperature en °C, 1 chiffre apres la virgule
        strcpy(temperature[0].mnemo,"temperature moult");  //
 
  temperature[1].addr[0]= 0x28; // capteur vert
  temperature[1].addr[1]= 0xFF;
  temperature[1].addr[2]= 0xF5;
  temperature[1].addr[3]= 0xD4;
  temperature[1].addr[4]= 0x61;
  temperature[1].addr[5]= 0x15;
  temperature[1].addr[6]= 0x01;
  temperature[1].addr[7]= 0x70;
  temperature[1].pin=8;
  temperature[1].valeur=1;      // temperature en °C, 1 chiffre apres la virgule
        strcpy(temperature[1].mnemo,"temperature chauffage");  //
 
 
 
// *********** initialisation des LED  *******************
 
pinMode (9,OUTPUT);// broche 10 configurée en sortie
pinMode (10,OUTPUT);// broche 10 configurée en sortie
 
digitalWrite(9,HIGH);
digitalWrite(10,HIGH);
 
}
 
 
/********************************************************************************
  Cette fonction permet d'allumer et d'éteindre une diode en focntion d'une
  température choisi.
********************************************************************************/
 
void loop(){
 
  gestion_temperature();
  delay(1000);
 
 if (palierEnCours == 0){
    Serial.print("On chauffe pour atteindre la temperature du 1er palier. Potar = ");
    Serial.println(temperature[0].mnemo);
    if (temperature[0].mnemo > 50){
      palierEnCours = 1;
      Serial.println("On entre dans le 1er palier");
    }
  }
 
  if (palierEnCours == 1){
    if (!verrouPalier1){
      palier1.demarrer(10000);                                              //On demarre la minuterie pour 30 min   (faire une fonction avec temps trampage, moult, fin,...  du style A1= 30 et reprendre dans la formule A1*60*1000)   
      EMPATAGE() ;                                                          // allumer ou éteindre la led du capteur rouge
      verrouPalier1 = true;                                                
      Serial.println("On active le palier 1 pour 10 sec");                 // On met a 1 le verrou afin de creer un front pour ne pas redémarrer la tempo.
    }
    if (!palier1.estTermine()){
      MOULT();                                                                            
    } 
    if (palier1.estTermine()){
      Serial.println("On a termine le 1er palier, on chauffe pour atteindre le Temp du 2e");
      palierEnCours = 2;      
    }
  }
 
  if (palierEnCours == 2){
    Serial.print("On chauffe pour atteindre la temperature du 2e palier. Potar = ");
    Serial.println(temperature[0].mnemo);
    if (temperature[0].mnemo > 62){
      palierEnCours = 3;
      Serial.println("On entre dans le 2 palier");
    }
  }
}
 
 
/********************************************************************************
  Cette fonction permet d'interroger tous les capteurs de temperature OneWire
  qui ont ete declare dans "temperature[i]"
********************************************************************************/
 
void EMPATAGE(){ // START (50°C)**********************************************************/
 
   if (  temperature[0].valeur > 23)
  {digitalWrite(9,LOW); // eteindre la led du capteur rouge (moult)
  } 
  if (  temperature[0].valeur < 20)
  {digitalWrite(9,HIGH); // eteindre la led du capteur rouge (moult)
  }
}
 
 
void MOULT(){  // MOULT (61°C)**********************************************************/
 
   if (  temperature[0].valeur > 61)
  {digitalWrite(9,LOW); // eteindre la led du capteur rouge (moult)
  } 
  else {digitalWrite(9,HIGH);
  }
}
 
void FIN(){ // FIN (75°C)**********************************************************/
 
   if (  temperature[0].valeur > 75)
  {digitalWrite(9,LOW); // eteindre la led du capteur rouge (moult)
  } 
  else {digitalWrite(9,HIGH);
  }
}
 
 
void gestion_temperature() // Mesure des températures****************************/
{
  byte i=0;
 
  for(i=0; i<NBRE_CAPTEUR; i++){
 
    Serial.print(temperature[i].mnemo);
    Serial.print(" => ");
    temperature[i].valeur =getStuff(temperature[i].addr,temperature[i].pin);
    Serial.print(temperature[i].valeur);
    Serial.println(" C ");
    delay(100);
  }
 
}
 
/********************************************************************************
  Cette fonction permet d'interroger le capteur de temperature OneWire
  qui a ?t? d?clar? dans "temperature[i]"
********************************************************************************/
float getStuff(byte addr[8], int pin) // indiquer le n? de pin ? utiliser
{
 
  OneWire  ds(pin);  // creation d'un objet OneWire avec le bon n? de pin
 
  byte i;
  byte present = 0;
  byte data[12];
 
  float real_temp;
  float temp_count;
  float read_temp;
 
 
  ds.reset();
  ds.select(addr);
  ds.write(0x44,1); // start conversion, with parasite power off at the end (1=parasite mode)
 
  delay(5000);     // delay de 1s si mode parasite. 100ms en mode normal
  // we might do a ds.depower() here, but the reset will take care of it.
 
  present = ds.reset();
  ds.select(addr);    
  ds.write(0xBE);         // Read Scratchpad
 
 
    for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
  }
 
  read_temp=((data[1]<<8) | data[0]) >> 1 ;            // Divide the temperature by 2
  temp_count=float(data[7] - data[6])/(float)data[7];  // Convert to real temperature
  real_temp = ((float)read_temp-0.25)+temp_count;
 
  // arrondi 1 chiffre apres la virgule
  int temp = real_temp*10;
  real_temp = (float)temp/100;
 
  // Serial.println();
 
  return real_temp;
}

Si j'ai bien comprit, mon erreur vient du fait que arduino ne comprend pas la lecture de la température lors de la gestion du palier comment faut il que j'écrive mon code?

Merci d'avance