PORT SÉRIE THREAD

// 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; 
*/