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:
 
 
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 ;
}

aucun réponce???????

Ben y'a presque plus rien à faire dans "ton" code...
 
Ou as-tu besoin d'aide précisément?
 
PS: s'il te plait utilise les balises [Code]

bonjour,
le problème c'est que lorsque je connecte mon régulateur avec le rs232 et j'écris un message par exemple:
4 48 48 49 49 2 83 76 50 50 3
qui le code ASCII du message qui change de la consigne de la température du régulateur a 22 degré rien ne change au niveau du régulateur.
et même si je veux lire la température afficher sur le régulateur je ne sais pas ou je peux déclaré le message convenable.
merci pour vous réponse.

1. Tu es sûr que c'est du C++ et non du C ?
 
2. void main(void) = peine de mort
Les deux prototypes valides de main sont :
int main(void)
et :
int main(int, char**)
 
3. J'ai eu la flemme de lire le reste du code
Tu dis que le régulateur ne modifie pas sa T° suite à ton message. Mais que répond ton régulateur lorsque tu le lui envoies ? Son message de réponse devrait t'aider à établir un diagnostic sur ce qui se passe...

bonjour,
le problème est que sur l'afficheur du régulateur rien ne change lorsque j'envoie un message et sur la fenêtre exécution du programme elle s'affiche le message est envoie.
donc je ne sais pas si le message est envoi vraiment ou non.
merci

D'après ton post initial : tu peux interroger le régulateur. Le faire te permettrait déjà de valider ta procédure d'envoi de messages et de réception de réponse du régulateur.
 
As-tu essayé d'interroger le régulateur pour voir ?

j'ai pensé à ça mais je sais pas ou je peux déclarer la trame de lecture dansle code.

Elle est déjà déclarée non?

TrameRecue = new char[200] ;

Je te conseil déjà de vérifier que les paramètre RS232 soient ceux attendus par ton régulateur. Actuellement ton réglage est 9600bauds, 8bits, 1 bit de stop, pas de parité.

Si tu a accès à un oscilloscope, vérifie que ta trame est bien envoyée, et vérifie également si ton régulateur répond.

Vérifie également le câblage.

Vérifie que ton message soit correct, t'as la spec de ton régulateur?

Enfin relis tes messages quand tu poste, ton orthographe et grammaire laissent un peu à désirer...