envoi et reception d'une trame sous rs232

**azert2010** · 23/03/2011, 17h43

bonjour
je suis entrain d'ecrire un programme pour faire la communication entre un PC et un regulateur eurotherm à l'aide du rs232.
j'ai fait un programme pour cette tache mais je ne sais pas comment envoyer et recevoir une trame de type:
-Pour la lecture des données, un message ‘d'interrogation’ est envoyé à l'appareil. Ce message a la syntaxe suivante :
[EOT](GID)(GID)(UID)(UID)(CHAN)(C1)(C2)[ENQ]
Si l'appareil reçoit correctement le message et si le mnémonique est valable, il répond par
[STX](CHAN)(C1)(C2)<DATA>[ETX](BCC)
-Pour l'écriture des données, un message de ‘sélection’ est envoyé à l'appareil. Ce message a la syntaxe suivante :
[EOT](GID)(GID)(UID)(UID)[STX](CHAN)(C1)(C2)<DATA>[ETX](BCC)

est ce que vous pouvez m'aidez pour avancer dans mon projet.
vous trouvez ci joint le code du programme:

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
int InitCOM(char *Port,char *Parite,char *Vitesse,char *Data,char *StopBit) 
{ 
   DCB dcb; // déclarer une variable contenant la configuration du port 
   HANDLE hCom; // déclarer un handle 
   DWORD dwError; // n° de l’erreur 
   BOOL fSuccess; // tout c’est bien passé 
   /*--------------------------------------------------------*/ 
   /* Ouverture du port de Com */ 
   /*--------------------------------------------------------*/ 
   hCom = CreateFile( 
      Port, // Choix du port « COMx » 
      GENERIC_READ | GENERIC_WRITE, // accès pour lire et écrire sur le port 
      0, // accès exclusif au port de COM 
      NULL, // sécurité par défaut 
      OPEN_EXISTING, //Doit être à cette valeur car se n’est pas un fichier 
      0, 
      NULL // mode synchrone 
      ); 
   /*-----------------------------------------------------------*/ 
   /* Vérifier si handle ouvert correctement */ 
   /*-----------------------------------------------------------*/ 
   if (hCom == INVALID_HANDLE_VALUE) 
   { 
      dwError = GetLastError(); 
      /* Fichier non créer Gérer l'erreur */ 
   } 
   /*-----------------------------------------------------------*/ 
   /* Lecture Configuration initiale */ 
   /*-----------------------------------------------------------*/ 
   fSuccess = GetCommState(hCom, &dcb); 
   if (!fSuccess) 
   { 
      /* Gérer l'erreur*/ 
   } 
   /*-------------------------------------------------------------------*/ 
   /* Configuration du port */ 
   /*-------------------------------------------------------------------*/ 
   /* Gestion de la vitesse */ 
   dcb.BaudRate = StrToInt(Vitesse); 
   /* Gestion du nombre de bits */ 
   dcb.ByteSize = StrToInt(Data); 
   /* Gestion de la parité */ 
   if (strcmp(Parite,"Aucune")==0) 
      dcb.Parity = NOPARITY; 
   if (strcmp(Parite,"Paire")==0) 
      dcb.Parity = EVENPARITY; 
   if (strcmp(Parite,"Impaire")==0) 
      dcb.Parity = ODDPARITY; 
   /* Gestion du Stop Bit */ 
   if (strcmp(StopBit,"1")==0) 
      dcb.StopBits = ONESTOPBIT; 
   if (strcmp(StopBit,"1.5")==0) 
      dcb.StopBits = ONE5STOPBITS; 
   if (strcmp(StopBit,"2")==0) 
      dcb.StopBits = TWOSTOPBITS; 
   dcb.DCBlength; 
   dcb.BaudRate; 
   dcb.fBinary=1; 
   dcb.fParity=0; 
   dcb.fOutxCtsFlow=0; 
   dcb.fOutxDsrFlow=0; 
   dcb.fDtrControl=0; 
   dcb.fDsrSensitivity=0; 
   dcb.fTXContinueOnXoff=0; 
   dcb.fRtsControl=0; 
   /*-----------------------------------------------*/ 
   /* Configurer le port */ 
   /*-----------------------------------------------*/ 
   fSuccess = SetCommState(hCom, &dcb); 
   if (!fSuccess) 
   { 
      /* Gérer l'erreur*/ 
   } 
   /*------------------------------------------*/ 
   /* fermer le port de com */ 
   /*------------------------------------------*/ 
   CloseHandle(hCom); 
   return(fSuccess); 
} 
 
/*-----------------------------------------------------------------------------*/ 
/* Envoyer une chaine de caractére sur la RS232 */ 
/* */ 
/* Paramètres : */ 
/* char *Chaine La chaine à Envoyer */ 
/* char *Port, le port de COM : "COM1" ou "COM2" */ 
/* char *EolChar, le caractère fin de ligne */ 
/* */ 
/* Retour : 0 si erreur */ 
/*-----------------------------------------------------------------------------*/ 
int EnvoiChaineRS232(char *Chaine,char *Port,char *EolChar) 
{ 
   HANDLE hCom; 
   DWORD dwError; 
   BOOL fSuccess; 
   DWORD dwEvtMask; 
   int i; 
   int NbOctet; 
   char *Message; 
   unsigned long nBytesWrite; 
   Message = new char[200]; 
   /*-----------------------------------------------*/ 
   /* Ouverture du port de communiucation */ 
   /*-----------------------------------------------*/ 
   hCom = CreateFile(Port, 
      GENERIC_READ | GENERIC_WRITE, 
      0, 
      NULL, 
      OPEN_EXISTING, 
      0, 
      NULL 
      ); 
   if(strcmp(EolChar,"CR")==0) 
      sprintf(Message,"%s%c",Chaine,0x0D); 
   if(strcmp(EolChar,"LF")==0) 
      sprintf(Message,"%s%c",Chaine,0x0A); 
   if(strcmp(EolChar,"LF/CR")==0) 
      sprintf(Message,"%s%c%c",Chaine,0x0A,0x0D); 
   if(strcmp(EolChar,"CR/LF")==0) 
      sprintf(Message,"%s%c%c",Chaine,0x0D,0x0A); 
   // compter le nombre d’octet à envoyer 
   NbOctet = StrLen(Message); 
   // écrire dans le fichier 
   WriteFile(hCom,Message,NbOctet,&nBytesWrite,NULL); 
   // Fermer le handle de com 
   CloseHandle(hCom); 
   // Libération mémoire 
   delete[] Message; 
   return(fSuccess); 
} 
/*------------------------------------------------------------------------------*/ 
/* Recevoir une chaîne de caractère sur la RS232 */ 
/* */ 
/* Paramètres : */ 
/* char *ChaineRecue , buffer de réception */ 
/* char *Port, le port de COM : "COM1" ou "COM2" */ 
/*------------------------------------------------------------------------------*/ 
int RecevoirRS232(char *Chaine Recue,char *Port) 
{ 
   DCB dcb; 
   HANDLE hCom; 
   DWORD dwError; 
   BOOL fSuccess; 
   BOOL bResult; 
   DWORD dwEvtMask; 
   COMMTIMEOUTS tTimeout; 
   unsigned long nBytesRead; 
   char *inBuffer; 
   int TimeoutRead; 
   int i; 
   int NbOctet; 
   char c; 
   /*-------------------------------------*/ 
   /* Initialisation des variables */ 
   /*-------------------------------------*/ 
   inBuffer = new char[200]; // réservation mémoire pour le buffer de récéption 
   sprintf(inBuffer,"%s",""); 
   nBytesRead=0; 
   /*-----------------------------------------------*/ 
   /* Ouverture du port de communication */ 
   /*-----------------------------------------------*/ 
   hCom = CreateFile(Port, 
      GENERIC_READ | GENERIC_WRITE, 
      0, 
      NULL, 
      OPEN_EXISTING, 
      0, 
      NULL 
      ); 
   /*----------------------------------*/ 
   /* Définition des timeouts */ 
   /*----------------------------------*/ 
   TimeoutRead = 500; // timeout de 500ms 
   tTimeout.ReadIntervalTimeout = MAXWORD; 
   tTimeout.ReadTotalTimeoutMultiplier = 0; 
   tTimeout.ReadTotalTimeoutConstant = TimeoutRead; // pas de time out = 0 
   tTimeout.WriteTotalTimeoutMultiplier = 0; 
   tTimeout.WriteTotalTimeoutConstant = 0; 
   // configurer le timeout 
   SetCommTimeouts(hCom,&tTimeout); 
   // fermer le port 
   CloseHandle(hCom); 
   // Libérer la mémoire 
   delete[] inBuffer; 
   return(fSuccess); 
} 
 
 
 
void main(void) 
{ 
   int Erreur ; 
   char *TrameRecue ; 
   TrameRecue = new char[200] ; 
   Erreur=InitCOM(« COM1 », « Aucune », « 9600 », « 8 », « 1 ») ; 
   if (Erreur !=0) // périphérique initialisé correctement 
   { 
      // envoi de la commande d’identification 
      EnvoiChaineRS232(« ID ? », « COM1 », « CR ») ; 
      // recevoir la réponse 
      RecevoirRS232(TrameRecue, « COM1 ») ; 
      // Traiter la trame reçue 
   } 
   else 
   { 
      // afficher une erreur 
   } 
   // Libération mémoire 
   delete[] TrameRecue ; 
}

**3DArchi** · 24/03/2011, 13h22

Salut,
Quel est ton problème exactement ? Car tout a l'air déjà présent dans le code que tu proposes.

**azert2010** · 24/03/2011, 13h29

bonjour,
mon porblem est au niveau d'envoi et de reception des trames, car lorsque j'essai d'envoyer une trame de type 04 30 30 31 31 02 53 4C 32 32 2E 30 03 02 en hexadecimale pour modifier la valeur de la consigne. Au niveau du regulateur rien ne change.
merci en avance

**3DArchi** · 24/03/2011, 13h48

Utilises le debugger. Ou écris tes données dans un fichier pour comprendre ce qui se passe (EnvoiChaineRS232(« ID ? », « mon_log.txt », « CR »)

**azert2010** · 24/03/2011, 15h46

bonjour,
pouvez vous m'expliquer c'est quoi ID et CR ?
merci

**3DArchi** · 24/03/2011, 16h32

Il n'y a qu'à lire la fonction correspondante :

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
int EnvoiChaineRS232(char *Chaine,char *Port,char *EolChar) 
{ 
   HANDLE hCom; 
   DWORD dwError; 
   BOOL fSuccess; 
   DWORD dwEvtMask; 
   int i; 
   int NbOctet; 
   char *Message; 
   unsigned long nBytesWrite; 
   Message = new char[200]; 
   /*-----------------------------------------------*/ 
   /* Ouverture du port de communiucation */ 
   /*-----------------------------------------------*/ 
   hCom = CreateFile(Port, 
      GENERIC_READ | GENERIC_WRITE, 
      0, 
      NULL, 
      OPEN_EXISTING, 
      0, 
      NULL 
      ); 
   if(strcmp(EolChar,"CR")==0) 
      sprintf(Message,"%s%c",Chaine,0x0D); 
   if(strcmp(EolChar,"LF")==0) 
      sprintf(Message,"%s%c",Chaine,0x0A); 
   if(strcmp(EolChar,"LF/CR")==0) 
      sprintf(Message,"%s%c%c",Chaine,0x0A,0x0D); 
   if(strcmp(EolChar,"CR/LF")==0) 
      sprintf(Message,"%s%c%c",Chaine,0x0D,0x0A); 
   // compter le nombre d’octet à envoyer 
   NbOctet = StrLen(Message); 
   // écrire dans le fichier 
   WriteFile(hCom,Message,NbOctet,&nBytesWrite,NULL); 
   // Fermer le handle de com 
   CloseHandle(hCom); 
   // Libération mémoire 
   delete[] Message; 
   return(fSuccess); 
} 
/*------------------------------------------------------------------------------*/ 
/* Recevoir une chaîne de caractère sur la RS232 */ 
/* */ 
/* Paramètres : */ 
/* char *ChaineRecue , buffer de réception */ 
/* char *Port, le port de COM : "COM1" ou "COM2" */ 
/*------------------------------------------------------------------------------*/ 
int RecevoirRS232(char *Chaine Recue,char *Port) 
{ 
   DCB dcb; 
   HANDLE hCom; 
   DWORD dwError; 
   BOOL fSuccess; 
   BOOL bResult; 
   DWORD dwEvtMask; 
   COMMTIMEOUTS tTimeout; 
   unsigned long nBytesRead; 
   char *inBuffer; 
   int TimeoutRead; 
   int i; 
   int NbOctet; 
   char c; 
   /*-------------------------------------*/ 
   /* Initialisation des variables */ 
   /*-------------------------------------*/ 
   inBuffer = new char[200]; // réservation mémoire pour le buffer de récéption 
   sprintf(inBuffer,"%s",""); 
   nBytesRead=0; 
   /*-----------------------------------------------*/ 
   /* Ouverture du port de communication */ 
   /*-----------------------------------------------*/ 
   hCom = CreateFile(Port, 
      GENERIC_READ | GENERIC_WRITE, 
      0, 
      NULL, 
      OPEN_EXISTING, 
      0, 
      NULL 
      ); 
   /*----------------------------------*/ 
   /* Définition des timeouts */ 
   /*----------------------------------*/ 
   TimeoutRead = 500; // timeout de 500ms 
   tTimeout.ReadIntervalTimeout = MAXWORD; 
   tTimeout.ReadTotalTimeoutMultiplier = 0; 
   tTimeout.ReadTotalTimeoutConstant = TimeoutRead; // pas de time out = 0 
   tTimeout.WriteTotalTimeoutMultiplier = 0; 
   tTimeout.WriteTotalTimeoutConstant = 0; 
   // configurer le timeout 
   SetCommTimeouts(hCom,&tTimeout); 
   // fermer le port 
   CloseHandle(hCom); 
   // Libérer la mémoire 
   delete[] inBuffer; 
   return(fSuccess); 
}

ID c'est la valeur du premier argument et CR celui du troisième. Que ne comprends-tu pas ?

**azert2010** · 25/03/2011, 00h14

bonjour,
le problem est que je veux envoyer et recevoir une trame en ASCII de la forme
_Pour l'écriture des données, un message de ‘sélection’ est envoyé à l'appareil. Ce message a la syntaxe suivante :
[EOT](GID)(GID)(UID)(UID)[STX](CHAN)(C1)(C2)<DATA>[ETX](BCC)

_Pour la lecture des données, un message ‘d'interrogation’ est envoyé à l'appareil. Ce message a la syntaxe suivante :
[EOT](GID)(GID)(UID)(UID)(CHAN)(C1)(C2)[ENQ]
Si l'appareil reçoit correctement le message et si le mnémonique est valable, il répond par
[STX](CHAN)(C1)(C2)<DATA>[ETX](BCC)

et lorsque j'entre ces trames rien ne change au niveau de regulateur.
cordialement

**3DArchi** · 25/03/2011, 07h26

Comment fais-tu l'envoi de ces trames. Peux tu montrer ces lignes ?

D'ailleurs ta fonction de réception n'a pas l'air fini. Il faut utiliser ReadFile comme tu utilises WriteFile pour l'écriture

envoi et reception d'une trame sous rs232

C++

Discussions similaires

Partager

Partager