[C++] Problème dans la classe RS232 [MFC]

Bonjour,
Je me trouve face à un réel problème.
En effet, j'ai codé une récupéré une classe RS232 pour mon projet qui fonctionne sur la version précédente de ce projet.
J'ai développé des classes qui utilisent un objet RS232.
Pour une raison qui m'échappe, ma classe ne fonctionne plus.
Pourriez vous m'éclairer...
Voici la classe sans les fichiers liés à l'IHM :
############################# RS232.h ###########################

#pragma once
#include <afxmt.h>

class CRS232
{

private:
char m_Port[5];
static const char m_CR=0x0D; // const char m_CR=0x0D;
int m_Vitesse; // 9600
int m_Nbrbits; // 8
int m_Parite; // false
int m_BitStop; // 1

HANDLE hcom; //Fichier de sortie sur le port COM
DCB dcb; //Config du Port

COMMTIMEOUTS timeouts; //time out
static const int TimeoutRead=500; // timeout de 500ms, 0 pas de time out

//Semaphore pour ne pas avoir des acces simultaner au port serie
CSemaphore m_Sem;

public:
CRS232(void);
~CRS232(void);
CRS232(int vitesse, int parite, float bitstop, int nbbits, char port[5]);
bool SetParam(int vitesse, int parite, float bitstop, int nbbits, char port[5]);
bool OuvrirPort(void);
bool FermerPort(void);
//retourne le combre de caracter lu
int LecturePort(char* bufer, int TailleBuf);
bool EcriturePort(char* Bufer, int TailleBuf);
};
############################# RS232.cpp #########################

#include "StdAfx.h"
#include "RS232.h"


CRS232::CRS232(void)
{
hcom=0;//Met à 0 hcom pour tester l'ouverture du port. Si le port est ouvert, le destructeur le ferme.

//parametres par défaut
strcpy(m_Port,"COM1");
m_Vitesse=9600;
m_Nbrbits=8;
m_Parite=1;
m_BitStop=0;// 0,1,2=>1,1.5,2 bits
}

CRS232::CRS232(int vitesse, int parite, float bitstop, int nbbits, char port[5])
{
hcom=0;//Met à 0 hcom pour tester l'ouverture du port. Si le port est ouvert, le destructeur le ferme.

//mise à jours des attributs
strcpy(m_Port,port);
m_Vitesse=vitesse;
m_Nbrbits=nbbits;
m_Parite=parite;

// 0=1bit de stop , 1=1.5bit de stop, 2=2bit de stop
if(bitstop==1)
{ m_BitStop=ONESTOPBIT;
}
if(bitstop==1.5)
{ m_BitStop=ONE5STOPBITS;
}
if(bitstop==2)
{ m_BitStop=TWOSTOPBITS;
}

}

CRS232::~CRS232(void)
{
if(hcom!=0)//test si le port serie a bien été ouvert pour le fermer ou non
{
CloseHandle(hcom);
}
}

bool CRS232::SetParam(int vitesse, int parite, float bitstop, int nbbits, char port[5])
{
//mise à jours des attributs
strcpy(m_Port,port);
m_Vitesse=vitesse;
m_Nbrbits=nbbits;
m_Parite=parite;

// 0=1bit de stop , 1=1.5bit de stop, 2=2bit de stop
if(bitstop==1)
{ m_BitStop=ONESTOPBIT;
}
if(bitstop==1.5)
{ m_BitStop=ONE5STOPBITS;
}
if(bitstop==2)
{ m_BitStop=TWOSTOPBITS;
}

return true;

}

bool CRS232::OuvrirPort(void)
{
//ouverture du port serie
hcom=CreateFile( m_Port , GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING , 0, 0);

//test de l'ouverture du port
if (hcom==0 || hcom==INVALID_HANDLE_VALUE)//si le port n'est pas ouvert on retourne false
{
return false;
}
else//si le port est ouvert on le paramètre
{
GetCommState(hcom, &dcb);//recuperation de la stucture de configuration du port

dcb.BaudRate = m_Vitesse ; // vitesse
dcb.ByteSize = m_Nbrbits ; // nombre de bits
dcb.Parity = m_Parite; // paritée
dcb.StopBits = m_BitStop; // bit de stop
dcb.fBinary = true; // doit ètre a true sur windows

//mise à jour de la configuration du port serie
SetCommState(hcom, &dcb);

//configuration des timout, pour les temps d'attente de lecture/ecriture sur le port
timeouts.ReadIntervalTimeout = MAXWORD;
timeouts.ReadTotalTimeoutMultiplier = 0;
timeouts.ReadTotalTimeoutConstant = TimeoutRead; // pas de time out = 0
timeouts.WriteTotalTimeoutMultiplier = 0;
timeouts.WriteTotalTimeoutConstant = 0;

//On applique les timeout au port
SetCommTimeouts(hcom,&timeouts);

return true;
}


}

bool CRS232::FermerPort(void)
{
if(hcom!=0)//test si le port serie a bien été ouvert
{
return CloseHandle(hcom);//fermeture du port
}
else
{
return false;
}
}

//retourne le combre de caracter lu
int CRS232::LecturePort(char* bufer, int TailleBuf)
{
DWORD result;

//memset(bufer,0,sizeof(bufer));

m_Sem.Lock();//utilisation du semaphore pour protégé l'acces au port serie
ReadFile(hcom, bufer, TailleBuf, &result, 0);//lecture sur le port
m_Sem.Unlock();//liberation du semaphore

if(result==0)//test de la lecture du port
{
return -1;
}
else
{
bufer[result]='\0';
return (result+1);
}
}

bool CRS232::EcriturePort(char* Bufer, int TailleBuf)
{
char chaine[30];
DWORD result;

strcpy(chaine,Bufer);
chaine[TailleBuf]=m_CR;//='\r';

m_Sem.Lock(); //utilisation du semaphore pour protégé l'acces au port serie
WriteFile(hcom, chaine, TailleBuf+1, &result, 0); //ecriture sur le port
m_Sem.Unlock(); //liberation du semaphore

if(result!=TailleBuf+1)//test de l'écriture sur le port
{
return false;
}
else
{
return true;
}
}


#################

Merci d'avance