guill.net
-
La page des réseaux
|
guill.net
-
La page des réseaux
|
|
|
Deuxième partie : Application des différente fonctions de gestion des Entrées / Sorties
Nous avons présenté dans le paragraphe précédent une liste de fonctions et de structures permettant la gestion des périphériques. Dans cette partie nous utiliserons ces fonctions pour configurer un port série et faire une lecture/écriture sur le port série.
Configuration du port série : exemple de fonction
/*------------------------------------------------------------------------*/
/*
Fonction d’initialisation d’un port RS232
*/
/*
*/
/* Paramétres
*/
/* char *Port
: "COM1" pour Port1, "COM2" pour port2
*/
/* char *Parite
: "Paire", "Impaire", "Aucune"
*/
/* char *Vitesse
: la vitesse en bauds
*/
/* char *Data
: le nombre de bit de donnée
*/
/* char *StopBit
: Le nombre de stop Bit
*/
/*
*/
/* Retour : un entier
egal à 0 si erreur.
*/
/*------------------------------------------------------------------------*/
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);
}
Ecriture sur un port série : Exemple de fonction d’envoie de donnée
/*-----------------------------------------------------------------------------*/
/*
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
);
/*--------------------------------------------------*/
/*
Envoi de la chaine + Eol caractére
*/
/*--------------------------------------------------*/
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);
}
Lecture sur un port série : Exemple de fonction de réception de données
/*------------------------------------------------------------------------------*/
/*
Recevoir une chaine 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 *ChaineRecue,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);
/*-------------------------------------------------------------*/
/*
boucle d'attente de lecture des octets
*/
/*
Sortie de la boucle par timeout par exemple, si
*/
/*
l’on suppose le format de la trame reçu n’est
*/
/*
variable.
*/
/*-------------------------------------------------------------*/
bResult = ReadFile(hCom,inBuffer,199,&nBytesRead,NULL);
if (nBytesRead!=0) // Il existe des octets lus
{
// Mettre en forme la trame : recherche de CR
}
else
sprintf(inBuffer,, »%s », “Pas de donnée reçue”)
;
sprintf(ChaineRecue,"%s",inBuffer); // Retourner la chaine recue
//
fermer le port
CloseHandle(hCom);
//
Libérer la mémoire
delete[]
inBuffer;
return(fSuccess);
}
Exemple d’appel de ses fonctions
Soit à configurer le port série 1, à 9600 bauds, sans de parité, 1 stop bit, 8 bits de data et envoyer la trame « ID ? » avec retour chariot à un périphérique qui nous retournera son identification. Un exemple de mise en œuvre est proposé ci après :
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 recue
}
else
{
// afficher une
erreur
}
// Libération
mémoire
delete[] TrameRecue
;
}