Discussion :

[alexorel]

Je travaille en ce moment sur un projet qui etablie une communication entre un pc sur WIn 98 et un periphérique par le port série.

En migrant l'application VS C++ sur WIn XP je me rends compte que ca ne fonctionne plus.

En gros j'établie une connection Asynchrone, j'envois une requète et je recupère la réponse.

Donc la connexion s'établie bien comme sur windows 98, j'envois ma chaine de carcatère avec WriteFile, ca à l'air de fontionner, mais le périphérique me renvoit rien, je ne recupère rien avec la ocmmande ReadFile.

J'ai fait une méthode simple qui regroupe tout ca, je l'ai testé sur 98 ca fonctionne mais pas sur XP.

J'ai deja établi beaucoup de recherche sur le net mais je ne trouve pas la solution.

Voila mon code pour la connexion

/************************************************************************
* Nom de la fonction : Open *
* En entrée : *
* Numero de port série *
* Vitesse de transmission (en bauds) *
* *
* En sortie : *
* TRUE si l'ouverture du port s'est bien passée *
* FALSE si problème dans l'ouverture du port *
* *
* Description : Ouverture du port de transmission *
*************************************************************************/

char szPort[15];
char szComParams[50];
DCB dcb;

BOOL CSerial::Open( int nPort, int nBaud )
{
COMMTIMEOUTS CommTimeOuts;
unsigned char ucSet;

if( m_bOpened )
return( TRUE );

wsprintf( szPort, "COM%d", nPort );

// Ouverture de la communication au port série
// On récupère le handle
m_hIDComDev = CreateFile( szPort,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL );


if( m_hIDComDev == INVALID_HANDLE_VALUE )
return( FALSE );

//--- Dimensionne les buffers d'entrée et sortie.
if ( !SetupComm(m_hIDComDev, 10000, 10000) )
return false;

if(GetCommTimeouts(m_hIDComDev, &CommTimeOuts))
{
CommTimeOuts.ReadIntervalTimeout = 0xFFFFFFFF;
CommTimeOuts.ReadTotalTimeoutMultiplier = 0;
CommTimeOuts.ReadTotalTimeoutConstant = 0;
CommTimeOuts.WriteTotalTimeoutMultiplier = 0;
CommTimeOuts.WriteTotalTimeoutConstant = 10000;
}

if(!SetCommTimeouts( m_hIDComDev, &CommTimeOuts ))
return( FALSE );

memset( &m_OverlappedRead, 0, sizeof( OVERLAPPED ) );
memset( &m_OverlappedWrite, 0, sizeof( OVERLAPPED ) );
m_OverlappedRead.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
m_OverlappedWrite.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );

dcb.DCBlength = sizeof( DCB );
if(!GetCommState( m_hIDComDev, &dcb ))
return ( FALSE );

dcb.BaudRate = nBaud; //1200 bauds
dcb.ByteSize = 7; //7 bits
dcb.StopBits = ONESTOPBIT; //1 stop
dcb.Parity = EVENPARITY; //Parity EVEN
dcb.fParity=true;
dcb.fDtrControl= DTR_CONTROL_DISABLE; //-5 sur la broche DTR pour commutation de la boîte

ucSet = (unsigned char) ( ( FC_RTSCTS & FC_DTRDSR ) != 0 );
ucSet = (unsigned char) ( ( FC_RTSCTS & FC_RTSCTS ) != 0 );
ucSet = (unsigned char) ( ( FC_RTSCTS & FC_XONXOFF ) != 0 );

if( !SetCommState( m_hIDComDev, &dcb ) ||
m_OverlappedRead.hEvent == NULL || m_OverlappedWrite.hEvent == NULL )
{
DWORD dwError = GetLastError();

if( m_OverlappedRead.hEvent != NULL )
CloseHandle( m_OverlappedRead.hEvent );

if( m_OverlappedWrite.hEvent != NULL )
CloseHandle( m_OverlappedWrite.hEvent );

CloseHandle( m_hIDComDev );
return( FALSE );
}
m_bOpened = TRUE;
return( m_bOpened );
}

La méthode qui ecrit et lit (qui ne fonctionne pas)

void CSerial::TestConnect()
{
DWORD nbr_octet_lu = 0;
DWORD nbr_octet_ecrit = 0;
char ucByte[100];

memset (ucByte,0,sizeof(ucByte));

strcpy(ucByte,"/?!**");
ucByte[3]=CR;
ucByte[4]=LF;

int bWriteStat = WriteFile( m_hIDComDev, ucByte, 5 , &nbr_octet_ecrit, &m_OverlappedWrite );
int dwWait = WaitForSingleObject( m_OverlappedWrite.hEvent, 1000 );
if ((dwWait == WAIT_FAILED) || (dwWait == WAIT_TIMEOUT))
{
if (dwWait == WAIT_FAILED)
return;
}

if(!GetOverlappedResult( m_hIDComDev, &m_OverlappedWrite, &nbr_octet_ecrit, FALSE ))
return;
else
m_OverlappedWrite.Offset += nbr_octet_ecrit;

memset (ucByte,0,sizeof(ucByte));

while(1)
{
int bReadStatus = ReadFile( m_hIDComDev, ucByte, 20, &nbr_octet_lu, &m_OverlappedRead);

//if (strcmp(ucByte,""))
if (*ucByte != 0 || nbr_octet_lu > 0 || strcmp(ucByte,""))
break;

dwWait = WaitForSingleObject( m_OverlappedRead.hEvent, 500 );
if ((dwWait == WAIT_FAILED) || (dwWait == WAIT_TIMEOUT))
{
if (dwWait == WAIT_FAILED)
return;
}
}

if (!GetOverlappedResult(m_hIDComDev, &m_OverlappedRead,&nbr_octet_lu, FALSE))
return;
}

[farscape]

salut,
essaye plutot ça :
http://c.developpez.com/faq/vc/?page...WithSerialPort

[alexorel]

En fait j'aurai aimai savoir les différences entre Win9x et XP.

Ce qui me permettrai de modifier mon code et non de tout refaire.

Si des personnes ont eu des problèmes selon les OS et comment elles ont procédées.

Apparemment le différence, en comparant le DEBUG des 2 OS, est que sur mon objet OVERLAPPED à la lecture et à l'écriture, INTERNAL resterai à 0, alors que sur 98, on a une valeur. Je sais pas à quoi c'est du et comment y remédier.

[ricky78]

Bonjour,
j'ai eu comme toi des problemes en passant du win98 au windows XP avec le port série.
J'ai résolu mon probleme en declarant la taille des buffer sous XP, ce que je ne faisait pas sous 98 avec la commande

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SetupComm(hPort,2048,2048);

De plus dans mon code j'utilisais la communication asynchrone mais mon appli demandant uniquement un ping pong sur le port je suis passer en synchrone ( le prog ne peut continuer que si il a reçu l'info echande de 1 caractere par 1 caractere) et le mode asynchrone me coutait environ 20% de vitesse

J'espere que cela pourra t'aider

[alexorel]

merci pour les infos,

je fais aussi un SetupComm, mes valeurs sont de 10000, 10000 est ce trop elevé, je vais faire des tests ce matin.

[alexorel]

Farscape, j'ai utilisé le code exemple que tu donnes, je l'ai intégré dans mon projet.

J'ai écris le code suivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
com->PortOpen(1, 300, 'E',7 ,1);
com->UseRtsCts();
 
com->SetCommMask(EV_RXCHAR); // spécifie l'événement d'attente.
strcpy(buffer,"/?!**");		//Requêtte 
buffer[3]=CR;				//CR
buffer[4]=LF;				//LF
com->WriteBuffer(buffer);
 
DWORD EvtMask;
if(com->WaitCommEvent(EvtMask))// attente réception 
{
	char sz[1000];
	com->ReadBuffer(sz,sizeof(sz));
}

Je me connecte j'envois une information, qui doit me renvoyer un code retour.
Mais ca plante sur le WaitCommEvent, j'ai le message d'erreur suivant :
"Une opération d'entrée/sortie avec chevauchement est en cours d'exécution."

Alors j'ai testé le code sur Win98 en me disant que je me suis peut être gourré dans la configuration d'accès, et la tout fonctionne parfaitement.
Donc le code est bon mais ca fonctionne pas sur XP je sais pas pourquoi.

[farscape]

salut,
bizarre tu es sur de ton buffer ? ,ton utilisation sous entend qu'il se termine par un \0.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
com->PortOpen(1, 300, 'E',7 ,1);
com->UseRtsCts();
 
com->SetCommMask(EV_RXCHAR); // spécifie l'événement d'attente.
CString str="/?!**";      //Requêtte
str+="\r\n";
com->WriteBuffer(str);
 
DWORD EvtMask;
if(com->WaitCommEvent(EvtMask))// attente réception
{
   char sz[1000];
   com->ReadBuffer(sz,sizeof(sz));
}

[alexorel]

En fait CR et LF c'est le retour chariot
ils sont definis
#define CR 0x0D
#define LF 0x0A

ce que tu as écris revient au même, j'ai quand même testé avec ton code, mais le résultat est le même. Je me demande si il n'y a pas un problème justement avec le retour chariot selon win98 ou XP.

Les spécifications de ma connexion sont les suivantes
Liaison série asynchrone Half Duplex
Vitesse de 300 bauds à l’ouverture puis commutée à 1200 bauds.
Le format est : 1 start bit, 7 databits, 1 bit de parité Even, 1 stop bit.
Le code caractère utilisé est l’ASCII international (ISO 1177)

Je me pose des questions sur le code caractère utilisé, comment on peut définir cela.

Merci pour ton aide.

[farscape]

salut,
je ne comprends pas trop ton probleme.
pour le retour charriot il n' y a pas de soucis .
j'ai fais l'essai en modifiant mon programme avec tes parametres d'ouvertures.
avec un modem USR comme peripherique je n'ai aucun probleme ça fonctionne sur mon poste.
tu peux peut etre faire l'essai pour valider que ce n'est pas un probleme materiel/config etc.
le seul probleme eventuel que je vois c'est la commutation de vitesse de 300 a 1200.

[alexorel]

Voila j'ai résolu mon problème !!!

en fait à la connexion il fallait que je mette le paramètre dtrControl à ENABLE.
Alors que sous 98 il est configuré en DISABLE et ca fonctionne ???

Second problème résolu il faut que je fasse une pause entre la connexion et l'écriture sur le périphérique de 200ms pour que cela fonctionne.
Mais ça c'est expliqué dans la doc technique de mon Schlumberger CF100.

Maintenant tout fonctionne bien, je vais pouvoir livrer ca à mon client, merci pour votre aide.