Discussion :

[GillesM57330]

Bonjour
Je récapitule le cahier des charges qui est simple.

Deux résistances, haut et bas chauffent un four .

J’allume la résistance du haut pendant un cycle de 3 secondes, je l'éteint, et j'allume la résistance du bas pendant un cycle 4 secondes je l'éteint, et allume le bas, et ainsi de suite..
Il ne faut JAMAIS que les deux résistances, haut et bas soient allumés en même temps,
Pendant le cycle de chauffe, si la température est atteinte, je sors du cycle, et passe à l'autre cycle de chauffe.

Je reçoit les informations, et commande les sorties via des modules USB.
Modules de saisie thermocouple USB
http://www.yoctopuce.com/FR/products...o-thermocouple
Module de commande relais USB ( Je dois utiliser une fonction pulse, et non mettre le relais sur ON, ou OFF ).
http://www.yoctopuce.com/FR/products...cto-powerrelay

J'ai conçu un programme qui enclenche un cycle de durée prédéterminée.

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
#include <unistd.h>   /* sleep() */
 
#include <iostream>
#include <time.h>
 
 
using namespace std;
 
 
int temperatureHaut ();  //-- Saisie de la Température sur Sonde du Haut
int temperatureBas ();    //-- Saisie de la Température sur Sonde du bas
 
int PulseBas (); //-- Fonction Pulse sur relais résistance haut
int PulseHaut (); //-- Fonction Pulse sur relais résistance bas
 
 
class Four
 
 {
     private:
          int consigneHaut;
          int consigneBas;
          int temps;
          time_t  depart;
 
     public:
          Four(int,int,int,time_t );
 
          int allumageminute ();
 
 
 
 
                                                                 };
// ----------  constructeur
 
 Four::Four(int regulHaut, int regulBas, int min, time_t  heure)
 
 {
           consigneHaut = regulHaut;
           consigneBas = regulBas;
           temps = min;
           depart = heure;
 
 
                                                          }
 
 
 
// -------- Fonction minutée
 
int Four::allumageminute()
 
{
      int a;
 
        sleep(1);
 
          time_t start;
          time (&start);
 
          a = difftime (start,depart);
 
 
    while ( a < temps)
 
 
{
      int ctr;
      int ctre;
            time (&start);
            a = difftime (start,depart);
 
 
          if (temperatureHaut ()< ( consigneHaut)- 0.5 )
 
              PulseHaut() ;
               cout<<"HAUT EN CHAUFFE";
               cout <<  endl ;
 
 
                     for (ctr = 0; ctr < 3; ctr++)
 
                         {
                               sleep(3);
 
                                  if (temperatureHaut ()< consigneHaut)
 
                                     break;
                                                                                }
 
 
               PulseHaut() ;
               cout <<  endl ;
 
 
 
            if (temperatureBas()< (consigneBas)- 0.5)
 
                PulseBas() ;
                cout<<"BAS EN CHAUFFE";
                cout <<  endl ;
 
                     for (ctre = 0; ctr < 4; ctr++)
 
                        {
                               sleep(4);
 
                                if (temperatureBas()< consigneBas)
 
                                  break;
                                                                                 }
 
 
                         PulseBas() ;
                         cout <<  endl ;
 
 
                                                                                                         }
 
 
 
 
                                                                                                                               }
// --------------------------------------------------------------------------------------------------------------------------------------
 
int main(int argc, char *argv[])
 
         {
 
 
             time_t a;
             time (&a);
 
             Four Baguettes(260,260,12,a); // (Températue demandée Haut,Température demandée Bas, temps de chauffe,"heure départ")
 
                     Baguettes.allumageminute();
                          cout<<"Vous avez cuit du pain pendant 4 Heures, ça sufit comme ça ";
 
                                           cout <<  endl ;
 
 
 
 
 
                                                                                                          }
 
// --------Fin Main
 
 
 int temperatureHaut ()
          {
                 int a = 10;
                  return a;
                                 }
 
 
 
 int temperatureBas ()
      {
                  int a = 12;
                  return a;
                                    }
 
 
 
int PulseHaut ()
{
  cout<<"Haut en Pulse" ;
     cout <<  endl ;
                               }
 
 
 
 
int PulseBas ()
{
  cout<<"Bas en Pulse" ;
   cout <<  endl ;

Merci.
Mon soucis se situe sur la conception et l’algorithme, les réglages de temps, se feront par la suite.

[bacelar]

Faut que l'on connaisse vraiment la criticité temps réel de votre "machin".

"sleep(1);", c'est bien tout pourri.
Ca redonne la main à l'ordonnanceur qui donnera la main à un autre thread durant un quantum de scheduling, qui est fonction de l'OS et de sa configuration, mais c'est 40ms minimum sous Windows non Real Time.

Moi, je ne comprend pas trop pourquoi votre code est si compliqué.

tantque temperatureHaut < consigneHaut || temperatureBas < consigneBas
---->Chauffe( Resistance := Haut, HeatMax := consigneHaut , TempsMax := 3000)
---->Chauffe( Resistance := Bas, HeatMax := consigneBas, TempsMax := 4000)

[GillesM57330]

Je fais tourner cette application sous Linux, la fonction sleep (1), est la seule que j'ai trouvé, pour faire une pause.

Je ne comprends pas bien ce que vous appelez "criticité temps réel ".

L"application sert de régulateur thermostatique, la règle, c'est de ne jamais avoir les deux résistances allumées en même temps et d'allumer les resistance, en alternant, haut et bas.

Pour allumer la resistance du haut, je fais un apel de fonction : "int PulseHaut ()"
Pour l'éteindre je refais un : "int PulseHaut ()"

Je saisi la température du haut, par une fonction : int temperatureHaut ()
Et ainsi de suite pour le bas.


Pour l'algo, je vais voir, ce que vous m'avez donné.
Je précise que je ne suis pas un pro de l'informatique, vous l'avez sans doute remarqué, je suis boulanger, j'ai fait du C++ il y a une paire d'années, ce programme est destiné à faire fonctionner un four, pour m'éviter d'acheter des régulateur classiques, avec tout le système de minuterie à faire poser.
Merci

[bacelar]

>Je fais tourner cette application sous Linux, la fonction sleep (1), est la seule que j'ai trouvé, pour faire une pause.

OK, j'ai confondu le "Sleep(en_milli_seconde)" de Windows avec le "sleep(en_seconde)" de Linux(POSIX).

Mais les limitations sont du même ordre.

Linux, comme Windows, ne sont pas, par défaut, des systèmes temps réel.

Quand on fait un sleep de 1 seconde, la seul garantie, c'est de ne pas avoir la main pendant AU MOINS une seconde, mais cela peu être 2,3 voir l'éternité si votre système est particulièrement chargé.

Je ne connais pas la criticité de votre application, mais je ne pense pas qu'une attente potentiellement infinie de votre application après un sleep soit acceptable.

Je ne comprends pas bien ce que vous appelez "criticité temps réel ".

Il y a beaucoup de type de temps réel : temps borné, temps en moyen, etc...
Chaque type de temps réel se gère de manière différente.

Mais je ne pense pas qu'échantillonner toutes les secondes pour une période de 3 secondes maximum soit suffisamment précis.
Et encore, le "toutes les secondes, c'est dans le meilleur des cas".

Linux non Temps Réel ne peut pas vous garantir que le programme soit réveillé toutes les secondes, même à un delta près, mais si vous avez un OS peu chargé, que vous mettez une fréquence d'échantillonnage bien plus fort, et une priorité d'exécution forte, vous ne devriez pas une garantie molle (empirique) de quelques dixièmes de secondes.

Je ne suis pas un spécialiste Linux mais usleep (http://linux.die.net/man/3/usleep) avec une fréquence assez élevé permettra cette garantie molle.

Après, pour vos contraintes, c'est juste une architecture logicielle simple :

c'est de ne jamais avoir les deux résistances allumées en même temps et d'allumer les resistance

Il suffit d'avoir une méthode Chauffe qui ne retourne que si la résistance n'est plus allumé.
Si Chauffe est la seule méthode qui allume une résistance et que vous éteignez toujours la résistance avant de sortir de la méthode, et que Chauffe ne s'appelle pas elle-même, vous avez la garantie de n'avoir qu'une résistance d'allumé à la fois.
Attention, la garantie de toujours éteindre la résistance en C++ demande à correctement gérer les exceptions.

PulseHaut/Bas, temperatureHaut/Bas etc..., semble être du code extrêmement proche, il faut donc essayer de factoriser le code pour qu'il soit commun aux deux résistances et se servir des paramètres pour faire la distinction entre les 2 résistences (comme axe de variabilité en théorie des langages).

Donc l'algo, pour moi, est toujours le même :
tantque temperatureHaut < consigneHaut || temperatureBas < consigneBas
---->Chauffe( Resistance := Haut, HeatMax := consigneHaut , TempsMax := 3000)
---->Chauffe( Resistance := Bas, HeatMax := consigneBas, TempsMax := 4000) .

[GillesM57330]

J'ai modifié l'algo, j'ai mis :

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
 
         if ((temperatureHaut ()< ( consigneHaut)- 0.5 ) || (temperatureBas()< (consigneBas)- 0.5) ) ;
 
              PulseHaut() ;
               cout<<"HAUT EN CHAUFFE";
               cout <<  endl ;
 
 
                     for (ctr = 0; ctr < 3; ctr++)
 
                         {
                               sleep(3);
 
                                  if (temperatureHaut ()< consigneHaut)
 
                                     break;
                                                                                }
 
 
               PulseHaut() ;
               cout <<  endl ;
 
 
                 PulseBas() ;
                cout<<"BAS EN CHAUFFE";
                cout <<  endl ;
 
                     for (ctre = 0; ctr < 3; ctr++)
 
                        {
                               sleep(3);
 
                                if (temperatureBas()< consigneBas)
 
                                  break;
                                                                                 }
 
 
                         PulseBas() ;
                         cout <<  endl ;
 
 
                                                                                                         }
 
                                                                                                                                         }

C"est bizarre si je met un ; " while", à la place du : " if " je rentre pas dans la boucle..

Pour la fonction Sleep je vais étudier le problème...
Merci

[GillesM57330]

Mais je pense qu'il y a un souci, j'ai mis 4 secondes en bas et 3 en haut, à titre d'exemple.

En fait, je chauffe 1 Min 30 S, en bas, et 1 Min en Haut.
Cela change peut être certainement la criticité, et le temps réel nécessaire.