Traiter en continue

**Mini-Tyson** · 06/03/2012, 09h40

Bonjour,
Je dois traiter en continue des trames sur port serie.
Je simule cela avec hyperterminal en le mettant sur mon port 1.

J'arrive à traiter une trame par une trame, en gros je dois relancer le programme à chaque fois !
Mais je voudrais les traiter en continue, je mets 20 trames dans hyperterminal, je veux qu'il me traite les 20 trames en continue sans relancer le programme !

Mon programme possède une classe WM918, pour les méthodes décapsulations et récupération de la trame et une autre pour traiter le port serie

Je pense que cela est possible avec un thread mais je n'ai pas d'idée de comment traiter ce problème

**pyros** · 06/03/2012, 13h42

Salut,

Avec ma boule de cristal, je vois que tu as une fonction qui traite une trame. Il suffit de faire un for(int i =0; i < 20; i++) pour traiter tes 20 frames...

Plus sérieusement, il nous faudrait un peu plus de code

**Mini-Tyson** · 06/03/2012, 14h53

Exact je vais poster en virant les parties qui se ressemblent.

Ma classe pour afficher mes résultats dans mon IHM

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
//---------------------------------------------------------------------------
__fastcall TAnalyse_Trames::TAnalyse_Trames(TComponent* Owner)
        : TForm(Owner)
{
        bool TrameRecue=false;
        WM918 Station("com1:", "4800,n,8,1");
        float MesureTempV=0;
        int MesureTempE=0;
        double MesureDirVent;
 
        //Réception d'une trame
        TrameRecue=Station.RecupData();
 
        if(TrameRecue==true)
                Station.DecapsuleTrame();
 
        MesureTempV =Station.LitTempVent(1);
        TemperatureVent->Text=MesureTempV;
 
        MesureTempE=Station.LitTempEau(1);
        TemperatureEau->Text=MesureTempE;
}

Ma classe pour traiter les trames

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
//Constructeur
WM918::WM918(String NPort,String Conf)
{
        TemperatureVent=0;
        TemperatureEau=0;
 
        //initialisation des attributs de la classe WM918
        NomPort=NPort;
        Config=Conf;
 
        NbTypeTraite=0; // reinitialisation avant une nouvelle analyse
 
        //instanciation d'un objet RS232
        LNavylec = new RS232(NomPort, Config);
}
//---------------------------------------------------------------------------
 
//Destructeur
WM918::~WM918()
{
        delete LNavylec;
}
//---------------------------------------------------------------------------
 
int WM918::MesuresTraitees()
{
        return NbTypeTraite;
}
//---------------------------------------------------------------------------
 
bool WM918::RecupData()
{
        bool RecupOk=false;
        const int TAILLETRAME=14;
        DWORD NbCar=0;
 
        AnsiString Trame="";
 
        TrameBrute="";
        Compteur=0;
 
        LNavylec->OuvrirPort(Erreur);
 
        while(LNavylec->ReadBuffer(Trame,Erreur))
        {
                NbCar = Trame.Length();
 
                if(NbCar>0)
                {
                        RecupOk=true;
                        Compteur=Compteur+NbCar;
                        TrameBrute=TrameBrute+Trame;
                }
 
                if(Compteur>=TAILLETRAME)
                {
                        LNavylec->FermerPort(Erreur);
                        return RecupOk;
                }
        }
 
        return RecupOk;
}
//---------------------------------------------------------------------------
 
bool WM918::DecapsuleTrame()
{
        bool            OperationTerminee=false;
 
        int             PositionInitiale=0,
                        PositionCourante=0;
 
        String          Inter="",
                        TempVentBrute="",
                        TemperatureEauBrute="";
        int             TEau=0;
        float           TempV=0;
 
 
        PositionInitiale=TrameBrute.Pos("$");
        PositionCourante=PositionInitiale+4;
        Inter=TrameBrute[PositionCourante];
 
        //TRAME TEMPERATURE DE L'AIR EXTERIEUR - girouette2
        if(Compteur==18& Inter=="D")
        {
                TempVentBrute=TrameBrute.SubString((PositionCourante+5),5);
                TempV=DecapsuleTemperatureVent(TempVentBrute);
                TemperatureVent=TempV;
        }
 
 
        //TRAME TEMPERATURE DE L'EAU - bateau2
        if(Inter=="T")
        {
                //if(Compteur==14)
        TemperatureEauBrute=TrameBrute.SubString((PositionCourante+3),2);
                TEau=DecapsuleTemperatureEau(TemperatureEauBrute);
                TemperatureEau=TEau;
 
        }
 
        OperationTerminee=true;
 
        return OperationTerminee;
}
//---------------------------------------------------------------------------
 
float WM918::DecapsuleTemperatureVent(String TempVentBrute)
{
        char    Negatif;
        int     Diz,
                Uni,
                Dixi;
        float   Resultat;
 
        Negatif=(TempVentBrute[1]  & 0xff);
        Diz=(TempVentBrute[2] & 0x0f);
        Uni=(TempVentBrute[3] & 0x0f);
        Dixi=(TempVentBrute[5] & 0x0f);
 
        if(Negatif==45)
                Resultat=-((Diz*10)+Uni+(Dixi*0.1));
        else
                Resultat=(Diz*10)+Uni+(Dixi*0.1);
 
        return Resultat;
}
//---------------------------------------------------------------------------
 
int WM918::DecapsuleTemperatureEau(String TemperatureEauBrute)
{
        char    Negatif;
        int     Diz,
                Uni;
        int     Resultat;
 
        Negatif=(TemperatureEauBrute[1] & 0xff);
        Uni=(TemperatureEauBrute[2] & 0x0f);
 
        if(Negatif!=45)
        {
                Diz=(TemperatureEauBrute[1] & 0x0f);
                Resultat = (Diz*10)+Uni;
        }
        else
                Resultat = -Uni;
 
        return Resultat;
}
//---------------------------------------------------------------------------
 
float WM918::LitTempVent(float MesureTempV)
{
        float Res;
        Res = TemperatureVent;
        return Res;
}
//---------------------------------------------------------------------------
 
int WM918::LitTempEau(int MesureTempE)
{
        int Resultat;
        Resultat = TemperatureEau;
        return Resultat;
}

Il reste la trame qui s'occupe du port serie !

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
//Constructeur
 
RS232::RS232()
{
        NomPort="Com1";
        ConfigPort="4800,N,8,1";
        EtatLigne= Fermee;
}
 
RS232::RS232(AnsiString NPort)
{
        NomPort=NPort;
        ConfigPort="4800,N,8,1";
        EtatLigne= Fermee;
}
 
RS232::RS232(AnsiString NPort,AnsiString CPort)
{
        NomPort=NPort;
        ConfigPort=CPort;
        EtatLigne= Fermee;
}
RS232::~RS232()
{
}
 
bool RS232::OuvrirPort(DWORD &ErreurLigne)
{
        bool PortOpenned=false;
        if(EtatLigne!=Ouverte)
        {
                Com=CreateFile(NomPort.c_str(),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL);
                BuildCommDCB (ConfigPort.c_str(),&ParamPort);
                SetCommState(Com,&ParamPort);
                if(Com !=INVALID_HANDLE_VALUE)
                {
                        EtatLigne=Ouverte;
                        PortOpenned = true;
                }
                else
                {
                        ErreurLigne=GetLastError();
                        PortOpenned=false;
                }
        }
        return PortOpenned;
}
 
bool RS232::FermerPort(DWORD &ErreurLigne)
{
        bool test=false;
        if(EtatLigne==Ouverte)
        {
                test = CloseHandle(Com);
                ErreurLigne=GetLastError();
                EtatLigne=Fermee;
        }
        return test;
}
 
bool RS232::ReadBuffer(AnsiString &Buf ,DWORD &ErreurLigne )
{
        bool BufReaded = false;
        char c;
        int i;
        DWORD NbrCar;
        if(EtatLigne==Ouverte)
        {
                ClearCommError(Com, &ErreurLigne, &StatutPort);
                i = StatutPort.cbInQue;
                while(i!=0)
                {
                        BufReaded = ReadFile(Com, &c, 1, &NbrCar, NULL);
                        Buf = Buf + c;
                        i--;
                }
        }
        return NbrCar;
}
 
bool RS232::ReadChar(char &Carac ,DWORD &ErreurLigne )
{
        bool ReadCh=false;
        char c=Carac;
        AnsiString Buf;
        int i;
        DWORD NbrCar;
        if(EtatLigne==Ouverte)
        {
                ClearCommError(Com, &ErreurLigne, &StatutPort);
                i = StatutPort.cbInQue;
                while(i!=0)
                {
                        ReadCh = ReadFile(Com, &c, 1, &NbrCar, NULL);
                        Buf = Buf + c;
                        i--;
                }
        }
        return ReadCh;
}
 
bool RS232::SendString(AnsiString &chaine,DWORD &ErreurLigne)
{
        bool SendSt=false;
        AnsiString ch=chaine;
        unsigned long NbrCarWrite;
        if(EtatLigne==Ouverte)
        {
                SendSt = WriteFile( Com, ch.c_str(), ch.Length(), &NbrCarWrite, NULL );
        }
        return SendSt;
}
 
bool RS232::SetConfig(AnsiString config)
{
        bool test=false;
        if(Com != INVALID_HANDLE_VALUE)
        {
                ConfigPort=config;
                test=true;
        }
        return test;
}
 
bool RS232::SetCom(AnsiString NPort)
{
        bool test=false;
        if(Com != INVALID_HANDLE_VALUE)
        {
                NomPort=NPort;
                test=true;
        }
        return test;
}

je vois pas comment utiliser un thread, quand j'en place un à chaque fois le programme plante ou ne prend pas en compte les nouvelles trames

**dragonjoker59** · 06/03/2012, 15h01

Tu dois juste avoir un thread qui tourne en boucle et qui récupère les trames :

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
MaTrame trame;
int iTimeout = 100;// temps d'attente entre chaque tentative
while( ! bEnded )
{
	if( RecevoirUneTrame( & trame ) )
	{
		// ici on a reçu une trame
		TraiterTrame( & trame );
	}
	else
	{
		//RAF
	}
	Sleep( iTimeout );//Pour laisser la main
}

Ton thread possède bien entendu le contexte de connexion.

[EDIT]
Avec le code de ton main j'aurais certainement écrit un code plus proche du tien

**Mini-Tyson** · 06/03/2012, 15h14

déjà merci

j'avais tenter un truc comme ça (moins élaboré)

au niveau de ce passage

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
while(LNavylec->ReadBuffer(Trame,Erreur))
        {
                NbCar = Trame.Length();
 
                if(NbCar>0)
                {
                        RecupOk=true;
                        Compteur=Compteur+NbCar;
                        TrameBrute=TrameBrute+Trame;
                }
 
                if(Compteur>=TAILLETRAME)
                {
                        LNavylec->FermerPort(Erreur);
                        return RecupOk;
                }
        }

Mais étant donné que je lance mon programme en mode pas à pas pour coller ma trame dans hyperterminal quand j'arrive à ce passage

Code :

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

while(LNavylec->ReadBuffer(Trame,Erreur))

cela ne donne rien de bien concluant

toi tu placerais ton code dans la partie IHM ?

**dragonjoker59** · 06/03/2012, 15h35

ton ReadBuffer ne doit pas être la condition d'arrêt (je suppose que cette fonction retourne le nombre d'octets lus).
En fait le bEnded que j'ai utilisé doit être mis à true à un autre endroit de ton appli, par exemple quand tu dois la fermer tu mets bEnded à true et tu attends la fin de ton thread avant de quitter l'appli

Traiter en continue

Langage C++

Vue hybride

Discussions similaires

Partager

Partager