Traiter en continue

Version imprimable

06/03/2012, 09h40
Mini-Tyson

Traiter en continue

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 :(
06/03/2012, 13h42
pyros

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 :)

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

Ma classe pour afficher mes résultats dans mon IHM

Code:

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:

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:

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 :(

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

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 :P

déjà merci

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

au niveau de ce passage

Code:

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:

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

cela ne donne rien de bien concluant :(

toi tu placerais ton code dans la partie IHM ?

06/03/2012, 15h35
dragonjoker59

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
06/03/2012, 16h49
Mini-Tyson

Je vois pas comment mettre en pause pour que la trame soit prise en compte :(

si je colle pas la trame dans hyperterminal au bon moment rien ne fonctionne :(

c'est peut-être tout con mais j'ai pas d'idée :?
06/03/2012, 17h25
dragonjoker59

Tu n'as normalement pas à mettre en pause.
Pour lire en continu, il faut que tu scrutes continuellement si des données arrivent.
Donc ton thread tourne en boucle en essayant à chaque tour de boucle de lire ce qu'il peut y avoir dans le buffer de comm.
S'il n'y a rien (ReadBuffer qui renvoie 0 ou qqchose dans le genre), il n'y a aucun traitement à effectuer, on Sleep pour laisser la main pendant un temps (et ne pas surcharger le processeur inutilement) puis on recommence.
donc dans ta boucle tu ne dois pas avoir de return sinon tu termines ton thread et ensuite tu ne pourras plus rien lire.
Tout ton traitement doit donc être fait dans le thread.
06/03/2012, 19h48
Mini-Tyson

Je vois pas comment faire aussi :(

Je pensais avoir été clair ...

Code:

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
MaTrame Trame;
int iTimeout = 100;// temps d'attente entre chaque tentative
bool bEnded = false;
int iNbRead;
int iNbTotal = 0;
// Il faut scruter en boucle
while( ! bEnded )
{
	// Un tour de boucle : 
	LNavylec->ReadBuffer( Trame, Erreur );// On scrute l'arrivée de données
	iNbRead = Trame.Length();// On regarde si on a reçu des données
 
	if( iNbRead > 0 )
	{
		// Des données sont arrivées, on les ajoute au buffer courant
		iNbTotal += iNbRead;
		TrameBrute=TrameBrute+Trame;// L'a pô compris cette ligne (ajout au buffer courant ? Où est défini l'opérateur '+' sur une trame ?)
	}
 
	if( iNbTotal >= TAILLETRAME )
	{
		// On a enfin reçu une trame complète (je suppose ?), on la traite
		// On retire la taille de la trame au décompte total
		iNbTotal -= TAILLEFRAME;
		// TODO : Retirer les données du buffer courant
	}
 
	Sleep( iTimeout );
}
 
LNavylec->FermerPort(Erreur);

08/03/2012, 09h30
Mini-Tyson

J'avais testé un truc du genre sans le sleep et j'ai le meme résultat en faites je ne sors jamais de la boucle donc il traite pas la trame qu'il a reçu
si j’agrandis tout plante :(:cry:

au début j'avais tenté de mettre le return dans la boucle mais au final la boucle ne sert à rien :(
08/03/2012, 09h40
dragonjoker59

Le traitement de la trame peut être fait de plusieurs façons.
1 - Tu peux faire le traitement dans le thread de réception (dans le if( iNbTotal >= TAILLETRAME ))
2 - Tu peux faire le traitement dans un thread à part (par exemple dans le thread principal de ton application) en faisant bien attention de protéger ta trame avec au moins des sections critiques pour les accès concurrents entre threads, ou en gérant une pile de trames reçues (pile qui sera protégée contre les accès concurrents, évidemment)
08/03/2012, 09h54
Mini-Tyson

merci pour cette réponse très rapide :ccool:

1/ ça va faire une méga grosse fonction et ça me retire une fonction de faire ça, ça fait pas bourrin ?
2/ Le problème c'est que comment faire pour mettre un thread à part si je ne sors pas de la boucle :(
08/03/2012, 10h54
dragonjoker59

Euh ... Normalement la boucle est dans un thread à part (qui ne fait que ce traitement).

1 - Effectivement ça fait une grosse fonction qui fait tout, je ne ferais pas comme ça.
2 - Il suffit que ton thread de traitement connaisse ait connaissance soit de la pile de trames (via un pointeur, par exemple, je suis pas fan), soit de la classe gérant cette pile (je préfère, permet de protéger la pile via les accesseurs)