Un chrono pour un logiciel d'acquisition de temps au tour.

**Joh266** · 22/02/2012, 12h16

Bonjour à tous,

J'ai actuellement un projet à faire en c++, mais projet à application réelle que j'ai choisit moi même... Peut être ai-je vu trop haut vu notre niveau actuel... Il y a un bout de code que je ne sais pas faire et je n'arrive pas à trouver comment faire.

Je travaille, cdcf oblige, sur builder 2010, mon problème étant que tout marche, sauf que je ne peux pas faire d'acquisition automatique grâce à un chrono dans mon timer car ... Bah je sais pas pourquoi...

Le logiciel récupère en rs232 la position haut ou bas d'un capteur (infrarouge, ce qu'on veut), via des modules experts toussa, grâce à un timer qui ping tout le temps, et le code réponse récupéré déclenche un chrono, puis s'il se redéclenche, arrête ce chrono, sauvegarde le temps, et le redémarre. Mais je sais pas faire le chrono...

Pouvez vous m'aider, ou bien m'aiguiller, et me conseiller sur que faire ? Je sais pas si j'ai suffisamment expliqué, hésitez pas à me poser des questions pour que je sois plus clair.

Voici l'ihm et le code :

le .cpp

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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
 
//---------------------------------------------------------------------------
#include <vcl.h>
#include <time.h>
#include "Classement_temps.h"
#include "windows.h"
 
#pragma hdrstop
#pragma package(smart_init)
#pragma link "IWBaseComponent"
#pragma link "IWBaseHTML40Component"
#pragma link "IWBaseHTMLComponent"
#pragma link "IWExtCtrls"
#pragma resource "*.dfm"
 
TClassement *Classement;
//---------------------------------------------------------------------------
__fastcall TClassement::TClassement(TComponent* Owner)
	: TForm(Owner)
{}
//---------------------------------------------------------------------------
void __fastcall TClassement::BenregistrerTempsClick(TObject *Sender)
{
	char nom[80] = "";
	char temps[80]="";
	char texte[80]="";
	Capteur->secPilote = EtempsCapte->Text.ToDouble();
	strcpy (Capteur->nomPilote, Eparticipant->Text.t_str());
	sprintf (nom, "%s",Capteur->nomPilote);
	Mnom->Lines->Add(nom);
	sprintf (temps, "%.2f",Capteur->secPilote);
	Mtemps->Lines->Add(temps);
	unsigned long nbreOctetsEcrits;
	SetFilePointer(hFichierClassement, 0, 0, FILE_END);
	WriteFile (hFichierClassement, &Capteur, sizeof(Capteur), &nbreOctetsEcrits, 0);
 
	sprintf (texte, "Pilote : %s ; Temps : %.2f secondes",Capteur->nomPilote,Capteur->secPilote);
	MlisteCapte->Lines->Add(texte);
}
//---------------------------------------------------------------------------
void __fastcall TClassement::BrecupClick(TObject *Sender)
{
	unsigned long tailleFichier=SetFilePointer(hFichierClassement,0,0,FILE_END);
	unsigned long nbreEnregistrements=tailleFichier/sizeof(Capteur);
	unsigned long nbreOctetsLu;
	char nom[80] = "";
	char temps[80]="";
	unsigned int j=0;
 
 
	SetFilePointer(hFichierClassement,0,0,FILE_BEGIN);
 
	for (j=0;j< nbreEnregistrements;j++);
	{
		ReadFile(hFichierClassement,&Capteur,sizeof(Capteur),&nbreOctetsLu,0);
		sprintf(nom,"%s",Capteur->nomPilote);
		Mnom->Lines->Add(nom);
		sprintf(temps,"%.2f",Capteur->secPilote);
		Mtemps->Lines->Add(temps);
	}
}
//---------------------------------------------------------------------------
 
void __fastcall TClassement::CreerOuvrirClick(TObject *Sender)
{
	char chNomFichier[250];
	if (OpenDialog1->Execute())
	{
		strcpy(chNomFichier,OpenDialog1->FileName.t_str());
		if(!strchr(chNomFichier,'.')) strcat(chNomFichier,".txt");
		hFichierClassement=CreateFile(chNomFichier,GENERIC_WRITE|GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
		if(hFichierClassement==INVALID_HANDLE_VALUE)
		{
			hFichierClassement=CreateFile(chNomFichier,GENERIC_WRITE|GENERIC_READ,0,NULL,CREATE_NEW,FILE_ATTRIBUTE_NORMAL,NULL);
		}
		char test[300]="Fichier en cours de modification : \n";
		Lfichier->Caption=strcat(test,chNomFichier);
		Brecup->Enabled=true;
		BenregistrerTemps->Enabled=true;
	}
}
//---------------------------------------------------------------------------
void __fastcall TClassement::FermerClick(TObject *Sender)
{
	CloseHandle(hFichierClassement);
	Lfichier->Caption="Veuillez créer ou ouvrir un fichier de sauvegarde du classement avant tout !";
	Brecup->Enabled=false;
	BenregistrerTemps->Enabled=false;
	Mtemps->Clear();
	MlisteCapte->Clear();
	Mnom->Clear();
}
//---------------------------------------------------------------------------
 
void __fastcall TClassement::QuitterClick(TObject *Sender)
{
	Close();
}
 
//---------------------------------------------------------------------------
 
void __fastcall TClassement::BdemarrerClick(TObject *Sender)
{
	if(Bdemarrer->Caption=="Démarrer Timer")
	{
		Timer1->Enabled=True;
		Bdemarrer->Caption="Arret Timer";
	}
	else
	{
		Timer1->Enabled=False;
		Bdemarrer->Caption="Démarrer Timer";
	}
	if(Timer1->Enabled==True)
	{
		Mtimer->Clear();
		Mtimer->Lines->Add("Timer : ON");
	}
	else
	{
		Mtimer->Clear();
		Mtimer->Lines->Add("Timer : OFF");
	}
}
//---------------------------------------------------------------------------
 
 
 
void __fastcall TClassement::BinitialiserPortClick(TObject *Sender)
{
	char COM_choisi[6]="COM1";
	unsigned long vitesse=9600;
	unsigned char parite=0;
	unsigned char nbreBits=8;
	float nbreStop=1;
	unsigned char protocole=0;
	char chProtocole [16]="";
 
	Capteur= new CCapteur(COM_choisi,vitesse,parite,nbreBits,nbreStop,protocole);
 
	if(Capteur->etatPort==1)
	{
		BinitialiserPort->Caption="Port connecté";
		BinitialiserPort->Enabled=False;
		BfermerPort->Enabled=True;
 
		if (protocole==0) sprintf(chProtocole,"Aucun Protocole");
		if (protocole==1) sprintf(chProtocole,"RTS - CTS");
		if (protocole==2) sprintf(chProtocole,"Xon - Xoff");
	}
	else
	{
		// message erreur d'ouverture
		Application->MessageBox(L"LIAISON RS error : ne peut ouvrir de handle sur le COM ! !",NULL,MB_OK);
   }
}
//---------------------------------------------------------------------------
 
void __fastcall TClassement::BfermerPortClick(TObject *Sender)
{
	delete Capteur;
	BinitialiserPort->Caption="Initialiser le port";
	BinitialiserPort->Enabled=True;
	BfermerPort->Enabled=False;;
 
}
//---------------------------------------------------------------------------
 
 
 
void __fastcall TClassement::Timer1Timer(TObject *Sender)
{
	char Buf_emission[100];
	unsigned long nbCaractEmis;
	lstrcpy(Buf_emission,"$016");
	StrCat(Buf_emission,"\r\n");
	nbCaractEmis=Capteur->EmettreTrame(Buf_emission);
	if(nbCaractEmis==0)
	{
		Application->MessageBox(L"Default d'emission sur le Com !!", NULL, MB_OK);
	}
 
 
 
	char* Buf_reception="";
	unsigned int delai=100;
	unsigned int NbCaractRecus;
 
	if(Ereception=="")
	{
		if(Ereception!=Buf_reception)
		{
			Ereception->Text=Buf_reception;
			Refresh();
		}
	}
 
	Buf_reception=Capteur->RecevoirTrame(delai);
	NbCaractRecus=strlen(Buf_reception);
	if(NbCaractRecus==0)
	{
		strcpy(Buf_reception,"Pas de donnée reçue avant la Fin du time-out ! ! ");
	}
	Ereception->Text = Buf_reception;
 
}
//---------------------------------------------------------------------------
 
 
void __fastcall TClassement::Timer2Timer(TObject *Sender)
{
 
   /*	time_t depart, arrivee;
 
	char test[7];
	strcpy(test,Ereception->Text.t_str());
	while(test!="!3FFF00")
	//test=Buf_reception;
	if (test=="!3FFF00")
	{
 
    time(&depart);
 
 
	getchar();
 
	time(&arrivee);
	Memo1->Lines->Add(difftime(arrivee, depart); */
 
 
 
/*		char* test;
		strcpy(test,Ereception->Text.t_str());
 
	//test=Buf_reception;
	//if (test=="!3FFF00")
	//{
		clock_t start, end;
		double elapsed;
		start = clock();
		Sleep(1000);
		//if(test=="!3FFF00")
		//{
			end = clock();
			elapsed = ((double)end - start) / CLOCKS_PER_SEC;
			Memo1->Lines->Add(elapsed);
		//}
	//}   */
}
//---------------------------------------------------------------------------
 
void __fastcall TClassement::Button1Click(TObject *Sender)
{
	if(Button1->Caption=="Démarrer Timer")
	{
		Timer2->Enabled=True;
		Button1->Caption="Arret Timer";
	}
	else
	{
		Timer2->Enabled=False;
		Button1->Caption="Démarrer Timer";
	}
	if(Timer2->Enabled==True)
	{
		Mtimer2->Clear();
		Mtimer2->Lines->Add("Timer : ON");
	}
	else
	{
		Mtimer2->Clear();
		Mtimer2->Lines->Add("Timer : OFF");
	}
 
}
//---------------------------------------------------------------------------

le .h

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
 
//---------------------------------------------------------------------------
 
#ifndef Classement_tempsH
#define Classement_tempsH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include <Menus.hpp>
#include <Dialogs.hpp>
//---------------------------------------------------------------------------
#include "C_RS232.h"
#include "IWBaseComponent.hpp"
#include "IWBaseHTML40Component.hpp"
#include "IWBaseHTMLComponent.hpp"
#include "IWExtCtrls.hpp"
//---------------------------------------------------------------------------
class TClassement : public TForm
{
__published:	// Composants gérés par l'EDI
	TGroupBox *GBClassement;
	TMemo *Mnom;
	TMemo *Mtemps;
	TLabel *Lpos;
	TLabel *Lnom;
	TLabel *Ltemps;
	TMemo *Mpos;
	TGroupBox *GBPseudoEtTemps;
	TEdit *Eparticipant;
	TLabel *Lparticipant;
	TTimer *Timer1;
	TMainMenu *MainMenu1;
	TMenuItem *Fichier1;
	TMenuItem *Fermer;
	TMenuItem *Quitter;
	TButton *BenregistrerTemps;
	TEdit *EtempsCapte;
	TMemo *MlisteCapte;
	TLabel *LtempsCapte;
	TOpenDialog *OpenDialog1;
	TMenuItem *CreerOuvrir;
	TButton *Brecup;
	TGroupBox *GBApercu;
	TLabel *Lfichier;
	TMemo *Mtimer;
	TButton *Bdemarrer;
	TButton *BinitialiserPort;
	TButton *BfermerPort;
	TEdit *Ereception;
	TGroupBox *GroupBox1;
	TLabel *LdonnéesRecues;
	TMemo *Memo1;
	TTimer *Timer2;
	TButton *Button1;
	TMemo *Mtimer2;
	void __fastcall FermerClick(TObject *Sender);
	void __fastcall BenregistrerTempsClick(TObject *Sender);
	void __fastcall CreerOuvrirClick(TObject *Sender);
	void __fastcall QuitterClick(TObject *Sender);
	void __fastcall BrecupClick(TObject *Sender);
	void __fastcall BdemarrerClick(TObject *Sender);
	void __fastcall BinitialiserPortClick(TObject *Sender);
	void __fastcall BfermerPortClick(TObject *Sender);
	void __fastcall Timer1Timer(TObject *Sender);
	void __fastcall Timer2Timer(TObject *Sender);
	void __fastcall Button1Click(TObject *Sender);
private:	// Déclarations utilisateur
public:		// Déclarations utilisateur
	__fastcall TClassement(TComponent* Owner);
 
	HANDLE hFichierClassement;
	CCapteur *Capteur;
};
//---------------------------------------------------------------------------
extern PACKAGE TClassement *Classement;
//---------------------------------------------------------------------------
#endif

la définition des classes

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
 
#include <stdio.h>
#include <ExtCtrls.hpp>
//-------- Declaration de la classe RS232 -------------------------------------
class CRS232
{
   // Variables privées de la classe
   DCB dcb;                						//Declaration structure DCB
   HANDLE hcomm;           						// permet la gestion du COM (comme Gestion de fichier)
   unsigned long NbCaractRecus;
   unsigned long NbCarMaxi; 					// Taille maxi de la chaine recue, initialisée dans le constructeur
   char chTrameRecue[128]; 						// La taille de cette chaine doit correspondre à NbCarMaxi
 
 
   //variables et méthodes publiques
public:
   int etatPort;    							//indique l'etat du port
 
   CRS232(char COM_choisi[6],unsigned long vitesse,unsigned char parite,unsigned char nbreBits,
								float nbreStop,unsigned char Protocole);  // Constructeur  servant à initialiser la liaison
   unsigned long EmettreTrame(char*);
   char* RecevoirTrame(int delai);
   ~CRS232(); 									// Destructeur
};
 
//-------- Constructeur de la classe RS232 -------------------------
CRS232::CRS232(char COM_choisi[6],unsigned long vitesse,unsigned char parite,unsigned char nbreBits,
								float nbreStop,unsigned char Protocole)
{
	NbCarMaxi=128; 								// Taille maxi de chTrameRecue (variable privée de la classe)
	//création du handle sur le com choisi (Gestion des ports comme des fichiers)
	unsigned char stopBits ;
	stopBits=2*nbreStop-2;   					// stopBits=0,1,2 pour 1, 1.5, 2 bits de stop
 
	hcomm = CreateFile(COM_choisi,GENERIC_READ|GENERIC_WRITE,0,NULL,
                        OPEN_EXISTING,FILE_FLAG_WRITE_THROUGH,NULL);
 
	if(hcomm != INVALID_HANDLE_VALUE)    		// port com choisi = OK
    {
		BuildCommDCB(COM_choisi,&dcb); 			//initialisation structure dcb avec valeurs par defaut
		// Mise à jour structure dcb
		dcb.BaudRate = vitesse;     			//CBR_9600
		dcb.Parity = parite;        			//valeur entre 0 et 4 pour no,odd,even,mark,space
		dcb.ByteSize = nbreBits;    			// nbre de bits de données, valeur entre 5 et 8
		dcb.StopBits = stopBits;    			//valeur 0,1,2 pour 1, 1.5, 2 bits de stop
		dcb.fBinary = 1;            			//mode binaire sans controle  de EOF (necessairement =1 avec API Win32)
		// Compléments d'initialisation pour Windows Seven x64
		dcb.fOutxCtsFlow=0;						// desactive la surveillance  de CTS
		dcb.fOutxDsrFlow=0;						// desactive la surveillance  de DSR
 
		switch(Protocole)
        {
		case 0:  								//"AUCUN PROTOCOLE":
			{
				dcb.fDtrControl = DTR_CONTROL_DISABLE;
				dcb.fRtsControl = RTS_CONTROL_DISABLE;
				break;
			}
		case 1: 								//"RTS/CTS et DTR/DSR":
			{
			dcb.fDtrControl = 2;				//DTR_CONTROL_ENABLE;
			dcb.fRtsControl = 2;				//RTS_CONTROL_ENABLE;
			dcb.fOutxCtsFlow=1; 				//active CTS
			dcb.fOutxDsrFlow=1; 				//active DSR
 
			break;
			}
		case 2:									//"Xon / Xoff":
			{
			dcb.fOutX=TRUE; 					// stoppe l'emission sur XOFF et redémare sur XON
			dcb.fInX=TRUE;  					//envoi de XOFF si buffer>80%. Envoi XON si buffer < 50%
			break;
			}
		}
		dcb.EvtChar= 0x0d ; 					// Caractère d'évènement en réception (0x0d=RETURN par exemple)
		SetCommState(hcomm,&dcb); 				//initialise le COM avec structure dcb.
		etatPort=1;  							//signale le succès à l'ouverture du port
	}
	else
	{
		etatPort=0;  							//signale le defaut d'ouverture du port
    }
}
 
//-------- Destructeur de la classe RS232 -------------------------
CRS232::~CRS232()
{
    CloseHandle(hcomm);    						//tue le handle
	Application->MessageBox(L"Fermeture du port", NULL, MB_OK);//message PopUp
}
//-------- EmettreTrame de la classe RS232 -------------------------
unsigned long CRS232::EmettreTrame(char* chTrameAEmettre)
{
    //emission gérée par buffer dans windows
    unsigned long nb_caraemettre=strlen(chTrameAEmettre);
    unsigned long nb_car_emis=0;
    WriteFile(hcomm,chTrameAEmettre,nb_caraemettre,&nb_car_emis,0);
    return(nb_car_emis);
}
//-------- RecevoirTrame de la classe RS232 -------------------------
char* CRS232::RecevoirTrame(int delai)
{
     static char chTrameRecue[50];
 
     //  controle par time out appliqué à ReadFile
     COMMTIMEOUTS Timeout;    //instanciation de la structure  COMMTIMEOUTS (Builder)
     int DureeTimeoutRead = delai; // durée timeout en millisecondes
     Timeout.ReadIntervalTimeout = MAXWORD;
     Timeout.ReadTotalTimeoutMultiplier = 0;
     Timeout.ReadTotalTimeoutConstant = DureeTimeoutRead; // pas de time out = 0
     Timeout.WriteTotalTimeoutMultiplier = 0;
     Timeout.WriteTotalTimeoutConstant = 0;
     SetCommTimeouts(hcomm,&Timeout); // configure le timeout pour le port ouvert
 
     NbCaractRecus=1;
     unsigned long NbCarMaxi=100;
     ReadFile(hcomm,chTrameRecue,NbCarMaxi,&NbCaractRecus,0);
 
     //Remplacement du return (fin de trame) par NULL (fin de chaine)
     if(NbCaractRecus!=0)
     {
         NbCaractRecus=NbCaractRecus-1;  //  rang du dernier caractère recu
         chTrameRecue[NbCaractRecus]=0;  //  remplacement du dernier caractère par NULL
     }
     return  chTrameRecue;
}
//--------------------------------------------------------------------------------------
class CCapteur:public CRS232
{
	private:
	public:
		char nomPilote[15];
		double secPilote;
		CCapteur(char COM_choisi[6],unsigned long vitesse,unsigned char parite,unsigned char nbreBits,
								float nbreStop,unsigned char Protocole);
		void enrScore(double);
};
//--------------------------------------------------------------------------------------
CCapteur::CCapteur(char* COM_choisi,unsigned long vitesse,unsigned char parite,unsigned char nbreBits,
								float nbreStop,unsigned char Protocole):CRS232(COM_choisi, vitesse, parite, nbreBits,
								 nbreStop, Protocole)
{
		memset (nomPilote, 0x00, 15);
}
//--------------------------------------------------------------------------------------
void CCapteur::enrScore(double score)
{
	secPilote = score;
}

Merci d'avance :s

Un étudiant en galère

**DjmSoftware** · 25/02/2012, 10h41

Salut
une liste de questions et de remarques en vrac

ou est le strutograme ou un diagrame de la logique de fonctionnement
Durée du Timer 1 et Timer2
Pour quoi utilise tu des tampons de taille différente entre l'emission et la receptions de paquets
ou est le code d'activation de ton Timer2

En lieu et place de ta classe CRS232
tu peux utiliser un composant existant TComport qui a l'avantage d'avoir des évenement lors de la reception d'une trame, et qui va t'éviter l'utilisation de Timer

beaucoup de code inutile

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
 
if(Bdemarrer->Caption=="Démarrer Timer")
	{
		Timer1->Enabled=True;
		Bdemarrer->Caption="Arret Timer";
	}
	else
	{
		Timer1->Enabled=False;
		Bdemarrer->Caption="Démarrer Timer";
	}
	if(Timer1->Enabled==True)
	{
		Mtimer->Clear();
		Mtimer->Lines->Add("Timer : ON");
	}
	else
	{
		Mtimer->Clear();
		Mtimer->Lines->Add("Timer : OFF");
	}

Attention pas de code bloquant dans une procedure de timer

Code :

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

1
2
3
4
5
 
if(nbCaractEmis==0)
	{
		Application->MessageBox(L"Default d'emission sur le Com !!", NULL, MB_OK);
	}

Un chrono pour un logiciel d'acquisition de temps au tour.

C++Builder

Vue hybride

Discussions similaires

Partager

Partager