guill.net - La page des réseaux
 

Communication RS232 en C++ Builder
Auteur : Xavier Brun de l'ESEO, le 30/09/00


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


Suite

Retour