Port série thread

Soyez le premier à donner votre avis sur cette source.

Vue 19 012 fois - Téléchargée 1 490 fois

Description

c'est un code qui regoupe le port série et les threads... c'est tout

Source / Exemple :


// FICHIERS D'INCLUSION
//------------------------------------------------------------------------------
#include <windows.h>
#include <winbase.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <winerror.h>

// CONSTANTES
//-------------------------------------------------------------------------------
// Définition du code d'erreurs
typedef enum
{
    e_ErrCom_None,				// Pas d'erreur
    e_ErrCom_Creation,			// Erreur lors de la création du flux
    e_ErrCom_Utilise,			// Le port com est déjà utilisé
    e_ErrCom_Inexistant,		// Le port com n'existe pas
    e_ErrCom_Timeout,			// Timeout lors d'une émission-réception
    e_ErrCom_Emission,			// Erreur lors de l'émission
    e_ErrCom_Reception,			// Erreur lors de la réception
    e_ErrCom_Definition_Trame,  // Erreur de définition de la trame
} e_ErrCom;

// Nom du port série

// Définition des vitesses de communication
#define V1200       1200
#define V2400       2400
#define V4800       4800
#define V9600       9600

// Définition du nombre de bits
#define BITS_7  7
#define BITS_8  8

// Définition du nombre de bits de stop
#define BIT_DE_STOP_1   1
#define BIT_DE_STOP_2   2

// Définition de la parité
#define PAS_DE_PARITE   'N' //NOT OF PARITY
#define PARITE_IMPAIRE  'O' //ODD
#define PARITE_PAIRE    'E' //EVEN

// Codes de retour génériques
//#define OK 1
//#define KO 0

// Longueur max réservée pour une trame
#define LG_TRAME    1024 //1 KOctets

// PROTOTYPES
//----------------------------------------------------------------------------
e_ErrCom OuvreCom(char *strPort,long BaudRate,int BitsSize,int Parity,int StopBits);
e_ErrCom EmissionCom(const void *lpBuf, unsigned int nCount);
e_ErrCom ReceptionCom(void *lpBuf, unsigned int nCountMax, unsigned int *pCountRead);
void ERROR_MSG(e_ErrCom g_ErrCom);
void ThreadReception();
DWORD WINAPI dwThreadProc(LPVOID lParam);

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 

void FermeCom();

// VARIABLES GLOBALES
//-----------------------------------------------------------------------------
DCB g_DCB;                          // structure dcb du port
e_ErrCom g_ErrCom= e_ErrCom_None;   // Variable des erreurs de com
HANDLE g_hCom = 0;					// handle de la com (le fichier)
DWORD dwEvtMask = 0;				// événement qui se produit
OVERLAPPED g_ov;					// structure OVERLAPPED de Synchronisation I/O 
int g_Longueur;						// Longueur de trame
char g_Com[5];						// Les COM :COM1,COM2,COM3...
int Index;							// L'index des COM...

//******************************************************************************
//------------------------------------------------------------------------------
// FONCTION : main 
//------------------------------------------------------------------------------
// DESCRIPTION  :
// La fonction principale
//
//------------------------------------------------------------------------------
void main (void)
{
	//Declaration des variables:
	//Tableau de caractère à envoyer
	char TrameEnvoi[100]="S.O.S....";
	//Tableau de caractère reçus
	char TrameRecue[100];
	//Nombre maxi de caractère a lire(ici 100)
	unsigned int NbMaxCar=100;
	//Nombre de caractère reçus
	unsigned int NbCarRecus;

	for(Index=1;Index<=5;Index++)
	{
	sprintf(g_Com,"COM%d",Index);
    //Exemple de configuration du port serie :

    g_ErrCom=OuvreCom(g_Com,V9600,BITS_7,PAS_DE_PARITE,BIT_DE_STOP_1);
	printf("\nLes erreurs de la configuration du %s\n",g_Com);
	
	ERROR_MSG(g_ErrCom);

	g_Longueur=strlen(TrameEnvoi);
    //Exemple d'emission
    g_ErrCom=EmissionCom(&TrameEnvoi,sizeof(TrameEnvoi));
	printf("\nLes erreurs de l'envoi de la trame par le %s:\n%s \n",g_Com,TrameEnvoi);
	ERROR_MSG(g_ErrCom);
		//Test de reception avec le thread
	ThreadReception();

	}
		//Test de reception sans faire du thread
			// Exemple de reception 
				//g_ErrCom=ReceptionCom(TrameRecue,NbMaxCar,&NbCarRecus);
				//printf("Les erreurs de la reception de la trame \n%s \nd'une taille de %d caractères.\n",TrameRecue,strlen(TrameRecue));
				//ERROR_MSG(g_ErrCom);
				//getch();
}
//------------------------------------------------------------------------------
//******************************************************************************

//******************************************************************************
//------------------------------------------------------------------------------
// FONCTION : OuvreCom
//------------------------------------------------------------------------------
// DESCRIPTION  :
// Initialise et ouvre un port série
//
//------------------------------------------------------------------------------
// PARAMETRES   : 
//      - strPort       Nom du port "COM1", "COM2"
//      - BaudRate      Vitesse
//      - BitsSize      Taille de l'info
//      - Parity        Parité
//      - StopBits      Nombre de bits de stop
//
// RETOUR   :Code d'erreur
//------------------------------------------------------------------------------
e_ErrCom OuvreCom(char *strPort,long BaudRate,int BitsSize,int Parity,int StopBits)
{
    g_ErrCom = e_ErrCom_None;

    // On ouvre le port série
    g_hCom = CreateFile(strPort,
		GENERIC_READ | GENERIC_WRITE,
		0,
		NULL,
		OPEN_EXISTING,
		FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING,  //|  FILE_FLAG_OVERLAPPED ????
		NULL);

    if(g_hCom == INVALID_HANDLE_VALUE)
    {
        // Echec
        g_ErrCom=e_ErrCom_Creation;
    }
    else //Sinon
    {
        // On vide les buffers
        PurgeComm(g_hCom,PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);      

        // On paramètre le port série
        g_DCB.DCBlength = sizeof(DCB);
        //Configuration actuelle
        GetCommState(g_hCom, &g_DCB);
        //Modification du DCB
        g_DCB.BaudRate=BaudRate;		//Vitesse
        g_DCB.ByteSize=BitsSize;		//Taille de l'info
        g_DCB.Parity=Parity;			//Parité
        g_DCB.StopBits=StopBits;		//Nombre de bits de stop
        g_DCB.fDtrControl=DTR_CONTROL_DISABLE;
        //Configuration de la liaison serie
        SetCommState(g_hCom,&g_DCB);
    }
    return g_ErrCom;
}
//----------------------------------------------------------------------------
//****************************************************************************

//****************************************************************************
//----------------------------------------------------------------------------
// FONCTION : EmissionCom
//----------------------------------------------------------------------------
// DESCRIPTION  :
// Emission d'octets sur la liaison série
//
//----------------------------------------------------------------------------
// PARAMETRES   : 
//      -lpBuf Pointeur sur les octets a emettre
//      -nCount Nombre d'octet a emettre
//
//----------------------------------------------------------------------------
// RETOUR   :Code d'erreur
//----------------------------------------------------------------------------
e_ErrCom EmissionCom(const void* lpBuf,unsigned int nCount)
{   

    DWORD NumBytes=0;

    if(g_hCom!=NULL)
    {
        // pas d'erreur
        g_ErrCom=e_ErrCom_None;

        //Emission du buffer
        if(WriteFile(g_hCom,lpBuf,nCount,&NumBytes,NULL)==0)
        {
			//Erreur lors de l'émission
            g_ErrCom=e_ErrCom_Emission;
        }
    }
    else
        //Le port n'a pas été ouvert
        g_ErrCom=e_ErrCom_Creation;

    return g_ErrCom;

}
//---------------------------------------------------------------------------
//***************************************************************************

//***************************************************************************
//---------------------------------------------------------------------------
// FONCTION : ReceptionCom
//---------------------------------------------------------------------------
// DESCRIPTION  :
// Reception de caractères sur la liaison série
//
//---------------------------------------------------------------------------
// PARAMETRES   : 
//      -lpBuf Pointeur sur le buffer de caractère a lire
//      -nCountMax Nombre maxi de caractère a lire
//      -pCountRead Pointeur sur le nombre de caractères lus
//---------------------------------------------------------------------------
// RETOUR   :Code d'erreur
//---------------------------------------------------------------------------
e_ErrCom ReceptionCom(void *lpBuf,unsigned int nCountMax, unsigned int* pCountRead)
{
COMSTAT Stat;
DWORD Errors;
unsigned int NCarALire;
unsigned long NCarLus=0;

char *t;

    if(g_hCom!=NULL)
    {
        // on pari sur pas d'erreur
        g_ErrCom=e_ErrCom_None;
		t="Traitement";
		//	Pour éviter de générer un time out

        // Pour connaitre le nombre d'octets dans le buffer d'entrée
        ClearCommError(g_hCom,&Errors,&Stat);
        NCarALire=Stat.cbInQue;

        // On effectue la lecture si il y a des caractères présents
        if( (NCarALire>0)&&(NCarALire<=nCountMax) )
        {
            if(ReadFile(g_hCom,lpBuf,NCarALire,&NCarLus,NULL)==0)
            {       
                g_ErrCom=e_ErrCom_Reception;
            }
        }
		else 
			g_ErrCom=e_ErrCom_Definition_Trame;

  • pCountRead=NCarLus;
} else // Le port n a pas été ouvert g_ErrCom=e_ErrCom_Creation; // Compte rendu de l'exécution return g_ErrCom; } //--------------------------------------------------------------------------- //*************************************************************************** //----------------------------------------------------------------------- // FONCTION : FermeCom //----------------------------------------------------------------------- // DESCRIPTION : // Ferme le port série préalablement ouvert avec OuvreCom // //----------------------------------------------------------------------- // PARAMETRES : // Néant //----------------------------------------------------------------------- // RETOUR :Néant //----------------------------------------------------------------------- void FermeCom() { if(g_hCom!=NULL) { CloseHandle(g_hCom); } } //--------------------------------------------------------------------------- //*************************************************************************** /***************************************************************************/ //--------------------------------------------------------------------------- // FONCTION : ThreadReception //----------------------------------------------------------------------- // DESCRIPTION : // Creation du thread dwThreadProc(LPVOID lParam) // //----------------------------------------------------------------------- // PARAMETRES : // Néant //----------------------------------------------------------------------- // RETOUR :Néant //----------------------------------------------------------------------- DWORD dwThread = 0; void ThreadReception() { // id de notre thread // handle de notre thread HANDLE hThread = 0; // créé notre thread en le mettant en suspend(pause) hThread = CreateThread(NULL, 0, dwThreadProc, 0, CREATE_SUSPENDED, &dwThread); // si erreur lors de la création de notre thread if ( hThread == NULL ) { printf("erreur lors de la création du thread\n"); // GetLastError() te donne le code d'erreur si tu veux le récupérer } else // sinon, tout est okay { // lancement de l'exécution de notre thread ResumeThread(hThread); // et patiente jusqu'a ce que notre thread soit fermé WaitForSingleObject(hThread,100/*INFINITE*/); } //} } //--------------------------------------------------------------------------- //*************************************************************************** //*************************************************************************** //--------------------------------------------------------------------------- // FONCTION : dwThreadProc //----------------------------------------------------------------------- // DESCRIPTION : // Identification du thread par ID // Détéction de trame :l'attent que des caractères soit arrivés... // //----------------------------------------------------------------------- // PARAMETRES : // -LPVOID lParam: 32-bit message parameter //----------------------------------------------------------------------- // RETOUR :DWORD //----------------------------------------------------------------------- DWORD WINAPI dwThreadProc(LPVOID lParam) { DWORD dwResult=0; COMSTAT Stat; DWORD Errors; //Tableau de caractère reçus char TrameRecue[100]; int Compter; //Nombre maxi de caractère a lire(ici 100) unsigned int NbMaxCar=100; //Nombre de caractère reçus unsigned int NbCarRecus; //Nombre de caractère Lus unsigned long NCarLus=0; //Nombre de caractère a lire unsigned int NCarALire=0; char *attente; printf("\nDetection de trame par %s est en cours....\n", g_Com); ZeroMemory(&g_ov, sizeof(OVERLAPPED)); printf("\n\t(*)le thread est bien cree %d\n",GetCurrentThreadId()); //Identifies an event set to the signaled state when the transfer has been completed g_ov.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); printf("\n\n\nLes erreurs de la reception de la trame.\n"); if(!WaitCommEvent(g_hCom, &dwEvtMask, &g_ov)) { ClearCommError(g_hCom,&Errors,&Stat); //Si Errors=0 donc Opération réussie. g_ErrCom=e_ErrCom_Creation; Compter=0; while(g_ErrCom!=e_ErrCom_None) { if (Compter>=600/*Le nombre de tentative!!!*/) { attente="\n"; g_ErrCom=e_ErrCom_Timeout; break; } else attente="."; Compter=Compter+1; printf("%s",attente); g_ErrCom=ReceptionCom(TrameRecue,NbMaxCar,&NbCarRecus); if (g_ErrCom==e_ErrCom_None) { printf("\nDetail de la reception: \n"); printf("\t------------------------------------\n"); printf("\t| Le port | %s\t\t |\n",g_Com); printf("\t------------------------------------\n"); printf("\t| ID-Thread | %d\t\t |\n",GetCurrentThreadId()); printf("\t------------------------------------\n"); printf("\t| La trame | %s\t\t |\n",TrameRecue); printf("\t------------------------------------\n"); printf("\t| La taille | %d\t\t\t |\n",strlen(TrameRecue)); printf("\t------------------------------------\n\n\n"); printf("Fermeture du port."); Sleep(50000); FermeCom(); } } } ERROR_MSG(g_ErrCom); return 0; // c'est terminé } //----------------------------------------------------------------------- //*********************************************************************** //----------------------------------------------------------------------- // FONCTION : ERROR_MSG //----------------------------------------------------------------------- // DESCRIPTION : //La liste des erreurs que le port peut subir // //----------------------------------------------------------------------- // PARAMETRES : // -Code d'erreur //----------------------------------------------------------------------- // RETOUR :Néant //----------------------------------------------------------------------- void ERROR_MSG(e_ErrCom g_ErrCom) { switch (g_ErrCom) { case e_ErrCom_None: // Pas d'erreur printf("\n\n\t\t\t\t\t%d) Pas d'erreur\n\n\n",g_ErrCom); break; case e_ErrCom_Creation: // Erreur lors de la création du flux printf("\n\t\t\t\t\t%d) Erreur lors de la création du flux\n\n\n",g_ErrCom); break; case e_ErrCom_Utilise: // Le port com est déjà utilisé printf("\n\t\t\t\t\t%d) Le port com est déjà utilisé\n\n\n",g_ErrCom); break; case e_ErrCom_Inexistant: // Le port com n'existe pas printf("\n\t\t\t\t\t%d) Le port com n'existe pas\n\n\n",g_ErrCom); break; case e_ErrCom_Timeout: // Timeout lors d'une émission-réception printf("\n\t\t\t\t\t%d) Timeout lors d'une émission-réception\n\n\n",g_ErrCom); break; case e_ErrCom_Emission: // Erreur lors de l'émission printf("\n\t\t\t\t\t%d) Erreur lors de l'émission\n\n\n",g_ErrCom); break; case e_ErrCom_Reception: // Erreur lors de la réception printf("\n\t\t\t\t\t%d) Erreur lors de la réception\n\n\n",g_ErrCom); break; case e_ErrCom_Definition_Trame: // Erreur de définition de la trame printf("\n\t\t\t\t\t%d) Erreur de définition de la trame\n\n\n",g_ErrCom); break; default: // Demande non prise en compte printf("\n\t\t\t\t\t%d) Demande non prise en compte\n\n\n",g_ErrCom); } } /* typedef struct _DCB { // dcb DWORD DCBlength; // sizeof(DCB) DWORD BaudRate; // current baud rate DWORD fBinary: 1; // binary mode, no EOF check DWORD fParity: 1; // enable parity checking DWORD fOutxCtsFlow:1; // CTS output flow control DWORD fOutxDsrFlow:1; // DSR output flow control DWORD fDtrControl:2; // DTR flow control type DWORD fDsrSensitivity:1; // DSR sensitivity DWORD fTXContinueOnXoff:1; // XOFF continues Tx DWORD fOutX: 1; // XON/XOFF out flow control DWORD fInX: 1; // XON/XOFF in flow control DWORD fErrorChar: 1; // enable error replacement DWORD fNull: 1; // enable null stripping DWORD fRtsControl:2; // RTS flow control DWORD fAbortOnError:1; // abort reads/writes on error DWORD fDummy2:17; // reserved WORD wReserved; // not currently used WORD XonLim; // transmit XON threshold WORD XoffLim; // transmit XOFF threshold BYTE ByteSize; // number of bits/byte, 4-8 BYTE Parity; // 0-4=no,odd,even,mark,space BYTE StopBits; // 0,1,2 = 1, 1.5, 2 char XonChar; // Tx and Rx XON character char XoffChar; // Tx and Rx XOFF character char ErrorChar; // error replacement character char EofChar; // end of input character char EvtChar; // received event character WORD wReserved1; // reserved; do not use } DCB;
  • /
/*The OVERLAPPED structure contains information used in asynchronous input and output (I/O). typedef struct _OVERLAPPED { // o DWORD Internal; DWORD InternalHigh; DWORD Offset; DWORD OffsetHigh; HANDLE hEvent; //Identifies an event set to the signalled state when the transfer has been completed } OVERLAPPED;
  • /

Conclusion :


mon soft sera mis à jours dans x temps

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
1
Date d'inscription
mardi 22 juillet 2008
Statut
Membre
Dernière intervention
22 septembre 2008

Bonjour. est ce qu'on peu faire des mesures avec la rs232 par exemple(en ohms, volts, ampers, et mm la longeurs) merci d'avance pour tt information.
Messages postés
2
Date d'inscription
vendredi 5 janvier 2007
Statut
Membre
Dernière intervention
9 mai 2007

9600 baud ne représente pas 9600 bits/sec mais 9600 inversions de bits par second (passage de 0 à 1 ou de 1 à 0). C'est donc égal à 9600 bits par seconde seulement si ta trame est 01010101.
Messages postés
12
Date d'inscription
mercredi 3 novembre 2004
Statut
Membre
Dernière intervention
1 octobre 2005

je croit savoir que 9600 baud represente 9600 bits par seconde
si non j'espere que t'a eu ton bts tabounator
Messages postés
4
Date d'inscription
lundi 21 juin 2004
Statut
Membre
Dernière intervention
22 juin 2004

salut. moi jé une petite question. demin je passe mon bts dinformatique et je sen k le jury va me poser une question que jarrive pa répondre qui et.

comment calculer le temp de transmission dune commande.il y a 5octet envoyer pour la commande sur liasion serie RS232/485. vitesse de transfert 9600 baud. svp reponder moi avant demin mardi 22 avant 11h merci
Messages postés
4
Date d'inscription
lundi 21 juin 2004
Statut
Membre
Dernière intervention
22 juin 2004

salut. moi jé une petite question. demin je passe mon bts dinformatique et je sen k le jury va me poser une question que jarrive pa répondre qui et.

comment calculer le temp de transmission dune commande.il y a 5octet envoyer pour la commande sur liasion serie RS232/485. vitesse de transfert 9600 baud. svp reponder moi avant demin mardi 22 avant 11h merci
Afficher les 10 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.