création d'une minuterie ( problème itération )

**azer2010** · 08/04/2022, 00h15

bonjour à tous,

je vous explique le projet en c++, je suis entrain de faire un code test pour faire une minuterie (un compteur) qui incrémente ou décrémente selon le choix voulu pour ensuite l'adapter sur un arduino qui aura donc
1 BT pour les minutes, 1 BT pour les secondes, 1 BT pour lancer ou stopper le compteur.

donc sur le code si dessous vous avez mon code actuel ou je ne comprend pas,
pourquoi la décrentation ne va pas jusqu'a 0 M : 0 S que je lance le compteur quand je saisie 0
alors qui commence bien avec les secondes que j'ai indiquer manuellement puis s'arrêt juste à la décrementation des itération des secondes standard quand il arrivent a zeros.
il ne continuer pas l'itération jusqu'a que le minute ne soit a zeros aussi 0 m : 0s

J'espère avoir été assez clair dans la description du problème, merci d'avance de votre aide je suis dans mes début avec le language c++.
ps les fonctions ne sont pas tous déclarer sur le Main car je ne trouver pas mon problème donc j'ai recommencer un un bloc de code sur le Main directement!!!!

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
 
 
//### fichier_baseC++.cpp
 
 
 
 #include <iostream>
 #include<unistd.h> // pour le sleep
 
 using namespace std; // execution la fonction std par défault
 
// Etat pour le Bouton MIN 
 
unsigned short BT_MIN {0};
unsigned short BT_SEC {0};
unsigned short Bt_Start {0};
unsigned short Bt_Stop {1};
 
unsigned short Etat_MIN {0}; // = true
bool Etat_Start {0};
 
//#################################################################################
// ##### réglage manuel des minutes et secondes #####
 
unsigned short Manuel_Minutes {2}; 	// décrentation, des Minutes régler manuellement
unsigned short Manuel_Secondes {20}; 	// décrentation, des Secondes régler manuellement
 
unsigned short STD_Secondes {59}; // fonction Standard du temps des secondes.
unsigned short TempsEcouleMin ; // sauvegarde la décrentation de " M "
 
unsigned short NewManuel_Minutes	; // nouvelle valeur minute après décrémentation.
 
 
unsigned short set_S {0}; // remise à zeros, des secondes
 
//################################################################################
 // ### fonctions : ###
 
 void Clear() // fonction pour effacer la console 
 {
 	cout << "\x1B[2J\x1B[H";
 }
 
 void compteur_STD_Secondes() // FONCTION SECONDES STANDARD
 {
	do
 	{
  		//if( STD_S < 60 ) // tant que "S" est inférieur à 60, on décrémente -1 puis fera l'itération jusqu'a 0, qui sera alors FALSE et qui sortira de la boucle.
		//{
 
		cout << "\n\n [[ " << Manuel_Minutes << " M : " << STD_Secondes << " S ]] minuterie lancer	\n\n";
		sleep(1);
		STD_Secondes--;
	}
	while(STD_Secondes < 60);
 }
 
 void compteur_Manuel_SEC() // FONCTION SECONDES POUR REGLAGE MANUEL
 {
 
 	while(Manuel_Secondes < 50)
 	{
  		if( Manuel_Minutes < 50 ) // tant que "S" est inférieur à 60, on décrémente -1 puis fera l'itération jusqu'a 0, qui sera alors FALSE et qui sortira de la boucle.
		{
		//S = s;
 
		// affiche la décrémentation des minutes et secondes.
		cout << "\n\n [[ 1/ lance les secondes regler manuellement\n\n";
		cout << "[[ " << Manuel_Minutes << " M : " << Manuel_Secondes << " S ]] Secondes la minuterie\n\n";
		sleep(1);
		Manuel_Secondes--;
		}
	}
 }
 
 void compteur_General() // fonction du compteur Minutes et Secondes 
 {
 
	if(Manuel_Secondes < 50) // si les secondes du compteur sont infèrieur à 50 est lancer
		{
		compteur_Manuel_SEC(); // execute l'iteration des secondes régler manuellement
		}
 
	else 
	{
	do
	{ 
			Manuel_Minutes--;
			cout << "\n\n [[ 2/ lance les secondes regler Standard \n\n";
			cout << " ### exécution de boucle itération pour les Minute [XX] ### " << endl;
 
	 		cout << "\n\n ### [[ " << Manuel_Minutes << " Minute décrementé ]] ### \n\n"; // décrémentation des minutes 
 
			compteur_STD_Secondes();
			continue;
	}
 
	// tant que l'expression est vrai ont execute le bloc de code si dessus 		
	while( Manuel_Minutes < 60 );
 
	 cout << "\n\n########################## " << endl;
	 cout << "### minuterie terminer ### " << endl;
	 cout << "##########################\n\n" << endl;
	 cout << "\n\n Bip Bip Bip Bip Bip Bip Bip Bip ";
	}
 }
//#################################################################################
//################################################################################
//################################################################################
 
 // intput (D'ENTREE) du programme. // base du fichier c++  
 int main () {  
 
 cout << "\n ##*appui sur Bt_StartStop [ 0 ], pour lancer la minuterie  ou sinon sur [ 1 ] ##";
 cin >> Etat_Start; 
 
//bool LAnceMinute = Bt_StartStop == 0; // variable logique pour si la condition est vrai on lance la minuterie.
 
 cout << "\n\n\n\n########################\n" << endl;
 cout << "lancement du programme \n" << endl;
 cout << "########################\n\n" << endl;
 
 do
 {
  cout << "\n\n### [[ --> 01 <-- ]]\n";
 cout << "### [[ " << Manuel_Minutes << " : " << Manuel_Secondes << " S]] ### \n\n"; // décrémentation du compteur
 Manuel_Secondes--;
 sleep(1);
 }
 while ( Manuel_Secondes < 50 );
 
 NewManuel_Minutes = Manuel_Minutes;
 //NewManuel_Minutes--;
 
 if (( NewManuel_Minutes < 60 ) || ( STD_Secondes < 60 ))
 {
 	 NewManuel_Minutes--;
	 while ( STD_Secondes < 60 )
	 {	
 
	 cout << "\n\n### [[ Deux ]]\n";
	 cout << " ### [[ " << NewManuel_Minutes << " : " << STD_Secondes << " S]] ### \n\n"; // décrémentation du compteur
	 STD_Secondes--;
	 sleep(1);
	 }
 
 }
 
 return 0;
 
 } // fin de la fonction (main) du programme OUTPUT (Sortie).

**dalfab** · 08/04/2022, 12h09

Bonjour,

Je te propose plutôt de comprendre pourquoi parfois le décompte s'arrête. En effet tu effectues des boucles en utilisant while(STD_Secondes < 60), selon moi les secondes c'est un nombre compris entre 0 et 59 et donc ton test devrait toujours être vrai! En fait on finit par sortir de la boucle, je te propose de t'interroger pourquoi la boucle se termine parfois!

Tu es en C++, ta gestion "bidouille" des minutes et des secondes risque fort de t'amener nulle part. Je te propose de créer un objet Minuterie qui en interne s'occuperait des minutes et secondes.

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
class Minuterie {
public:
    Minuterie( int min, int sec ) : m_total{sec+min*60} {}     // créé à partir de min + sec
    Minuterie( int total_sec = 0 ) : m_total{total_sec} {}    // créé à partir d'un total en secondes
 
    int  minutes()const {     // retourne le nombre de minutes courant
        return  m_total / 60;
    }
    int  secondes()const {    // retourne le nombre de secondes courant
        return  m_total % 60;
    }
    Minuterie&  operator--() {  // le -- décompte une seconde
        --m_total;
        return  *this;
    }
    bool  estZero()const {
        return  m_total == 0;
    }
private:
    int  m_total;
};

Avec un objet de type Minuterie, tu peux initialiser avec une durée, décrémenter et lire à tout instant les minutes et secondes restantes.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int main() {
    Minuterie  ma_minuterie( 2, 30 );    // initialisée à 2min30
 
    while ( !ma_minuterie.estZero() ) {
        std::cout << "minutes : " << ma_minuterie.minutes() << " secondes : " << ma_minuterie.secondes() << std::endl;
        --ma_minuterie;  // une seconde de moins
    }
 
    ma_minuterie = Minuterie( 500 );  // initialisée à 500secondes
    std::cout << "minutes : " << ma_minuterie.minutes() << " secondes : " << ma_minuterie.secondes() << std::endl;
}

Toutes les "vilaines" variables globales ont disparues, plus d'incohérence entre minutes et secondes décomptées. C'était du C c'est devenu du C++!

**azer2010** · 08/04/2022, 13h23

Envoyé par dalfab

Bonjour,

Je te propose plutôt de comprendre pourquoi parfois le décompte s'arrête. En effet tu effectues des boucles en utilisant while(STD_Secondes < 60), selon moi les secondes c'est un nombre //...
}[/CODE]Toutes les "vilaines" variables globales ont disparues, plus d'incohérence entre minutes et secondes décomptées. C'était du C c'est devenu du C++!

merci beaucoup de ton temps et de ton explication tu a ensoleilé ma journée de pluie ^^, donc pour la boucle while dans la condition j'aurais du plutôt indique 59 au lieu de 60 pour que la boucle reste fausse ?

très bonne journée à toi dalfab, Que la force du C++ reste en toi.

**dalfab** · 08/04/2022, 14h05

Envoyé par azer2010

merci beaucoup de ton temps et de ton explication tu a ensoleilé ma journée de pluie ^^, donc pour la boucle while dans la condition j'aurais du plutôt indique 59 au lieu de 60 pour que la boucle reste fausse ?

très bonne journée à toi dalfab, Que la force du C++ reste en toi.

Absolument pas, 59s est bien un nombre de secondes valide et ton test le rejetterait. Il faut quitter la boucle quand les secondes arrivent à 0, un test plus logique serait : while(STD_Secondes >= 0), mais comme tes secondes sont non signées et fait ton test marche car 0-1 = 65535 en unsigned short qui lui est bien supérieur à 60, et on sort de la boucle une seconde après le 0. Ton test n'est pas si mal, mais à la fin tu as 65535 secondes, c'est capillotracté.

**Guesset** · 08/04/2022, 12h29

Bonjour,

La procédure compteur_STD_Secondes() ne décompte pas jusqu'à 0. Quand STD_Secondes = 0, le test STD_Secondes < 60 est toujours bon. On passe donc à l'itération suivante qui fait passer STD_Secondes à 255 car c'est un unsigned short.
Le test de fin de boucle devrait plutôt être : while(STD_Secondes > 0);Il y a beaucoup (trop) de variables globales.

La procédure compteur_Manuel_SEC() utilise 50 mais met 60 en commentaire. Même problème, la procédure se termine par Manuel_Secondes == 255 après 50 itérations.

Aucun bouton n'est géré.

sleep() n'est pas en ms ? Tel que c'est construit, la lecture éventuelle des boutons sera au mieux faite un fois par minute car nécessairement en dehors de la boucle de décrémentation. Plutôt que sleep(), il est préférable de lire le temps écoulé, généralement en ms, et d'actualiser les compteurs si nécessaire.

Je n'ai pas regardé la suite mais il y a des 50 et 60 qui se baladent...

Salutations