Lecture port com vc++, sans blocage ?

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Lecture port com vc++, sans blocage ?

evilbrood

Bonjour,
dans le cadre d'un stage, je dois réaliser une application qui récupère une trame via un port COM, ensuite convertir ces données, puis les envoyer sur un port Ethernet.

J'ai tout d'abord réalisé cette appli avec visual studio 2010, mais avec la console, le code fonctionne.

Maintenant je dois réaliser une interface graphique, j'ai donc opté pour des windowsforms sur vc++.

Le code fonctionne toujours, je peux recevoir des données via le port COM, puis les convertir et les envoyer sur le port Ethernet.
Mon seul problème est que j'ai utilisé un bouton pour lancer la lecture dur port COM, et que une fois le bouton appuyé, l'appli est bloquée tant qu'une trame n'est pas reçue sur le port COM.

Pour l'instant, le code de mon bouton est le suivant :

Code :

int nBytesRead=0, nBytesMessageRecu = 0, tailleMessageCOM=0;
char charBuffer[1024], IP[16] = "127.0.0.1";
int j, portSophie;
BOOL COM_SOPHIE2 = FALSE;
unsigned char message_conv_KLV[MAX_TEXT_KLV], recept_COM[TAILLE_MAX_COM];
klv_icd ^ klv_icd2 = gcnew klv_icd();
portCOM ^ portCOM2 = gcnew portCOM();
portSophie = (int)NUM_PORT_COM->Value;
TIM_COM->Enabled = 1;
// Lecture des deux premiers octets de la trame afin de récupérer la taille de la trame
while(nBytesMessageRecu < 2) {
if(portCOM2->COM_Sophie == 0){
if(portCOM2->OpenSophie(portSophie)){
portCOM2->COM_Sophie = TRUE;
this->TXT_ETAT_COM->Text = "Connexion OK !";
}
else this->TXT_ETAT_COM->Text = "No Connection !";
}
if(portCOM2->COM_Sophie) if(portCOM2->ReadSophie(charBuffer, 1, &nBytesRead) == 0) portCOM2->COM_Sophie = FALSE;
nBytesMessageRecu = 0;
if(portCOM2->COM_Sophie){
if(nBytesRead){
while(nBytesMessageRecu < 2) {
if(nBytesMessageRecu < 2) recept_COM[nBytesMessageRecu] = (unsigned char) charBuffer[0];
nBytesMessageRecu++;
portCOM2->ReadSophie(charBuffer, 1, &nBytesRead);
}
}
}
}
recept_COM[nBytesMessageRecu] = (unsigned char) charBuffer[0];
nBytesMessageRecu = 0;
//Lecture des octets restants
while((nBytesMessageRecu + 3) < (recept_COM[1] + 4)) {
if(!portCOM2->COM_Sophie) if(portCOM2->OpenSophie(portSophie)) portCOM2->COM_Sophie = TRUE;
if(portCOM2->COM_Sophie) if(!portCOM2->ReadSophie(charBuffer, 1, &nBytesRead)) portCOM2->COM_Sophie = FALSE;
nBytesMessageRecu = 0;
if(portCOM2->COM_Sophie){
if(nBytesRead){
while(nBytesRead) {
if((nBytesMessageRecu + 3) < (recept_COM[1] + 4)) recept_COM[nBytesMessageRecu+3] = (unsigned char) charBuffer[0];
nBytesMessageRecu++;
portCOM2->ReadSophie(charBuffer, 1, &nBytesRead);
}
}
}
}
portCOM2->CloseSophie();
//affichage de la trame reçue
...
...
...

Afin de résoudre ce problème, j'ai pensé à utiliser un timer, cette fonction se terminerait au bout de x secondes si elle n'a pas reçu de trame, mais je ne vois pas vraiment comment m'y prendre.
Ou alors utiliser des threads, mais là je vois encore moins, surtout qu'une fonction appellée dans un thread ne peut avoir qu'un argument ?

Si vous avez des idées, des pistes, je vous en remercie d'avance !

---------------
Mon topic de ventes matos informatique : http://forum.hardware.fr/hfr/Achat [...] 1897_1.htm

Publicité

xilebo

noone

il faut créer le port COM en mode OVERLAPPED , et ensuite faire un WaitForSingleObject sur le handle du port COM pour savoir s'il y a des données à lire ou non, et les lire le cas échéant. C'est un peu le même principe que le select en réseau.

Code :

// creation port
HANDLE serial_handle = CreateFile(buf, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING , FILE_FLAG_OVERLAPPED , NULL);
// creation event
OVERLAPPED overlap_read_evt;
memset(&overlap_read_evt, 0, sizeof(overlap_read_evt));
overlap_read_evt.hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
// ecoute sur le port
DWORD event_mask;
event_mask = EV_RXCHAR;
WaitCommEvent( serial_handle , &event_mask, &overlap_read_evt); // attache l event au handle , a réarmer à chaque appel
DWORD retwait = WaitForSingleObject(overlap_read_evt.hEvent, 1000); // attend 1000 ms s'il s'est passé quelque chose
if (retwait == WAIT_OBJECT_0)
{ // recu des données
ResetEvent(overlap_read_evt.hEvent);
ReadFile( serial_handle, mybuffer , mybuffersize, (DWORD*)&mybytesread, &overlap_read_evt) == 0);
}
else if (retwait == WAIT_TIMEOUT)
{ // rien recu
}
else if (retwait == WAIT_FAILED)
{ // erreur
}
// fermeture
CloseHandle( overlap_read_evt.hEvent );
CloseHandle( serial_handle );

evilbrood

Merci pour ta réponse rapide !

J'ai implémenté ta solution, effectivement, le programme attend bien le temps indiqué, puis laisse la main à l'interface.

Par contre, maintenant plus moyen de recevoir des données sur ce port, j'ai beau lui envoyer une trame, retwait vaut toujours "WAIT_TIMEOUT", à quoi est-ce du ?

J'ai créé une fonction renvoyant un DWORD (retwait), prenant en argument
- "unsigned char* buffer"
- "int portCOM" j'ai remplit 'buf' avec "\\\\.\\COM" + portCOM
- "int mybuffersize" qui correspond à la taille de la trame à recevoir

Le corps de la fonction correspond à ton code + remplissage de 'buf'

---------------
Mon topic de ventes matos informatique : http://forum.hardware.fr/hfr/Achat [...] 1897_1.htm

evilbrood

Petit up,
en fait j'ai implémenté la solution avec le port com overlapped, mon code est le suivant :

Code :

int portCOM::LectureCOM(unsigned char* buffer, int portCOM, int mybuffersize){
/* Délais d'attente sur le port COM Sophie */
COMMTIMEOUTS g_ctoSophie = {
MAX_WAIT_READ_SOPHIE, /* ReadIntervalTimeOut */
0, /* ReadTotalTimeOutMultiplier */
MAX_WAIT_READ_SOPHIE, /* ReadTotalTimeOutConstant */
0, /* WriteTotalTimeOutMultiplier */
0 /* WriteTotalTimeOutConstant */
};
/* Configuration du port COM Sophie */
DCB g_dcbSophie = {
sizeof(DCB), /* DCBlength */
115200, /* BaudRate */ //115200
TRUE, /* fBinary */
TRUE, /* fParity */
FALSE, /* fOutxCtsFlow */
FALSE, /* fOutxDsrFlow */
DTR_CONTROL_ENABLE, /* fDtrControl */
FALSE, /* fDsrSensitivity */
FALSE, /* fTXContinueOnXoff */
FALSE, /* fOutX */
FALSE, /* fInX */
FALSE, /* fErrorChar */
FALSE, /* fNull */
RTS_CONTROL_ENABLE, /* fRtsControl */
FALSE, /* fAbortOnError */
0, /* fDummy2 */
0, /* wReserved */
0x100, /* XonLim */
0x100, /* XoffLim */
8, /* ByteSize */
ODDPARITY, /* Parity */
ONESTOPBIT, /* StopBits */
//ONESTOPBIT, //DEBUG
0x11, /* XonChar */
0x13, /* XoffChar */
'?', /* ErrorChar */
0x1A, /* EofChar */
0x10 /* EvtChar */
};
char szCOM[16], charBuffer[1024];
int result, nBytesMessageRecu = 0;
int* nBytesRead = 0;
OVERLAPPED overlap_read_evt;
sprintf(szCOM, "\\\\.\\COM%d", portCOM);
HANDLE h_sophie2 = CreateFile(szCOM, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
if (h_sophie2 == INVALID_HANDLE_VALUE) result = 1;
/* affectation taille des tampons d'émission et de réception */
SetupComm(h_sophie2, RX_SIZE, TX_SIZE);
/* configuration du port COM */
if(!SetCommTimeouts(h_sophie2, &g_ctoSophie) || !SetCommState(h_sophie2, &g_dcbSophie)){
result = 2;
}
/* on vide les tampons d'émission et de réception, mise à 1 DTR */
PurgeComm(h_sophie2, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
EscapeCommFunction(h_sophie2, SETDTR);
memset(&overlap_read_evt, 0, sizeof(overlap_read_evt));
overlap_read_evt.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
DWORD event_mask;
event_mask = EV_RXCHAR;
WaitCommEvent(h_sophie2, &event_mask, &overlap_read_evt);
DWORD retwait = WaitForSingleObject(overlap_read_evt.hEvent, 6000);
if (retwait == WAIT_OBJECT_0){
ResetEvent(overlap_read_evt.hEvent);
// Lecture des deux premiers octets de la trame afin de récupérer la taille de la trame
while(nBytesMessageRecu < 2) {
nBytesMessageRecu = 0;
if(nBytesRead){
while(nBytesMessageRecu < 2) {
if(nBytesMessageRecu < 2) buffer[nBytesMessageRecu] = (unsigned char) charBuffer[0];
nBytesMessageRecu++;
ReadFile(h_sophie2, charBuffer, 1, (DWORD*)&nBytesRead, &overlap_read_evt);
}
}
}
buffer[nBytesMessageRecu] = (unsigned char) charBuffer[0];
nBytesMessageRecu = 0;
//Lecture des octets restants
while((nBytesMessageRecu + 3) < (buffer[1] + 4)) {
nBytesMessageRecu = 0;
if(nBytesRead){
while(nBytesRead) {
if((nBytesMessageRecu + 3) < (buffer[1] + 4)) buffer[nBytesMessageRecu+3] = (unsigned char) charBuffer[0];
nBytesMessageRecu++;
ReadFile(h_sophie2, charBuffer, 1, (DWORD*)&nBytesRead, &overlap_read_evt);
}
}
}
}
else if (retwait == WAIT_TIMEOUT){
result = 5;
}
CloseHandle(overlap_read_evt.hEvent);
CloseHandle(h_sophie2);
return result;
}

Le problème est que WaitForSingleObject(.....) renvoie toujours WAIT_TIMEOUT, même si j'envoie une trame sur le port désigné.
Je ne comprends pas vraiment pourquoi...

---------------
Mon topic de ventes matos informatique : http://forum.hardware.fr/hfr/Achat [...] 1897_1.htm

xilebo

noone

je regarderai en détail plus tard , juste pour info, j'ouvre le port com avec la chaine de caractère suivante : "COM1:" ou "COM2:" ou ...

evilbrood

Bon finalement j'ai contourné le problème.

Au lieu de configurer le port COM en OVRELAPPED, j'ai utilisé un timer.

A chaque évènement TICK du Timer, je lance une lecture sur le port COM, sauf que j'ai enlevé les boucles
- "while(nBytesMessageRecu < 2)"
- "while(nBytesMessageRecu + 3 < recept_COM[1] + 4)"

Ca fonctionne, avec une cadence de 10ms, le soft n'est pas bloqué, et les trames sont reçues.
Par contre, une fois sur deux environ, je ne reçoit pas la bonne trame, à quoi cela peut-il être du ? Peut être que à cause du timer, le prog commence à lire la trame "au milieu" de sa réception ?
Comment résoudre ce problème ? J'ai beau diminuer la cadence du timer, cela ne résout rien...

J'ai aussi une autre question qui me taraude, pour l'instant je déclare mes variables dans mes contrôles.
C'est à dire que à chaque TICK du timer (ou avant à chaque clic sur un bouton), je déclare mes variables (nBytesMessageRecu, recept_COM[]...).
Du coup ces dernières sont inaccessibles à l'extérieur de ce contrôle. Comment faire pour que mes variables soient accessibles depuis tous les contrôles ? J'ai bien essayé de les déclarer dans form_load, mais le problème est le même. Ou alors au début du fichier Form1.h, à cet endroit :

Code :

public ref class Form1 : public System::Windows::Forms::Form
{
public:
Form1(void)
{
InitializeComponent();
//
//TODO: ajoutez ici le code du constructeur
//
}
//Déclaration des variables à cet endroit ??
protected:
/// <summary>
/// Nettoyage des ressources utilisées.
/// </summary>
~Form1()
{
if (components)
{
delete components;
}
}

Mais j'ai des erreurs me disant que le type est managé et que cela n'est donc pas possible.

Ou les déclarer dans ce cas ? Ou alors comment y accéder depuis les autres contrôles ?

Merci d'avance

---------------
Mon topic de ventes matos informatique : http://forum.hardware.fr/hfr/Achat [...] 1897_1.htm

SquiZZ

Pour tes problèmes de lecture, ca me semble normal si tu utilises la fonction LectureCom de ton message précédent. A chaque appel tu ouvres le port, vides les buffers puis le referme.

Si tu es parti pour faire du C#, il faut (faudrait) que tu te fasse une classe pour gérer le port série avec :
- une méthode pour ouvrir et configurer les port (à appeler dans le constructeur de ta form)
- une méthode pour fermer le port (à appeler dans le destructeur de ta form)
- une methode de lecture, soit non bloquante à appeler dans un timer, soit bloquante à appeler dans un thread (suivant les paramètres de SetCommTimeout)

et déclarer une instance de cette classe dans la partie 'protected' du code que tu a posté ci-dessus.

Message édité par SquiZZ le 25-07-2012 à 14:49:04

evilbrood

Pour le coup des variables accessibles uniquement dans le contrôle où elles sont déclarées, le problème est réglé.
J'ai crée un fichier .h dans lequel j'ai fait mes déclarations, et j'ai inclus ce fichier au début de mon form1.h

Après pour la lecture du port COM, je n'ai pas précisé, je n'ai en fait pas utilisé la fonction LectureCOM.
Enfin au final tu as raison, j'ouvre et ferme le port série à chaque fois.

Effectivement, à chaque évènement Tick, je fais ceci :

Code :

int nBytesRead=0, nBytesMessageRecu = 0, tailleMessageCOM=0;
char charBuffer[1024];
int j, portSophie;
BOOL COM_SOPHIE2 = FALSE, COM_RECEIVED = FALSE;
unsigned char recept_COM[TAILLE_MAX_COM];
klv_icd ^ klv_icd2 = gcnew klv_icd();
portCOM ^ portCOM2 = gcnew portCOM();
portSophie = (int)NUM_PORT_COM->Value;
if(!COM_SOPHIE2) if(portCOM2->OpenSophie(portSophie)){
COM_SOPHIE2 = TRUE;
TXT_ETAT_COM->Text = "Connexion OK";
}
else TXT_ETAT_COM->Text = "No Connection";
if(COM_SOPHIE2) if(!portCOM2->ReadSophie(charBuffer, 1, &nBytesRead)){
COM_SOPHIE2 = FALSE;
portCOM2->CloseSophie();
}
nBytesMessageRecu = 0;
if(COM_SOPHIE2){
if(nBytesRead){
while(nBytesMessageRecu < 2) {
if(nBytesMessageRecu < 2) recept_COM[nBytesMessageRecu] = (unsigned char) charBuffer[0];
nBytesMessageRecu++;
portCOM2->ReadSophie(charBuffer, 1, &nBytesRead);
}
}
}
recept_COM[nBytesMessageRecu] = (unsigned char) charBuffer[0];
nBytesMessageRecu = 0;
//Lecture des octets restants
if(!COM_SOPHIE2) if(portCOM2->OpenSophie(portSophie)) COM_SOPHIE2 = TRUE;
if(COM_SOPHIE2) if(!portCOM2->ReadSophie(charBuffer, 1, &nBytesRead)) COM_SOPHIE2 = FALSE;
nBytesMessageRecu = 0;
if(COM_SOPHIE2){
if(nBytesRead){
while(nBytesRead) {
if((nBytesMessageRecu + 3) < (recept_COM[1] + 4)) recept_COM[nBytesMessageRecu+3] = (unsigned char) charBuffer[0];
nBytesMessageRecu++;
portCOM2->ReadSophie(charBuffer, 1, &nBytesRead);
COM_RECEIVED = TRUE;
}
}
}
portCOM2->CloseSophie();
if(COM_RECEIVED){
//affichage de la trame reçue
.....
//Lecture de la trame - extraction des coordonnées
if(klv_icd2->extractFields(recept_COM, recept_COM[1] + 4, &reponseSophie) == 1){
//Affichage des coordonnées
....
//Conversion en KLV
klv_icd2->reponseToKLV(reponseSophie, message_conv_KLV);
//Affichage des cooronnées en KLV
....
}
}

Si j'ai bien compris, ce que tu me conseille de faire, c'est :
- Ouvrir le port série au lancement de l'application
- Lire le port série dans un timer, ou avec un thread
- Fermer le port quand on quitte l'application
C'est bien ça ?

Le problème, c'est que je dois pouvoir modifier le port COM à lire quand l'application est lancée, du coup il faudrait ouvrir le port COM quand on modifie le n° du port ?
Et le fermer (si il a été ouvert) à ce moment aussi ?

Message édité par evilbrood le 25-07-2012 à 15:42:07

---------------
Mon topic de ventes matos informatique : http://forum.hardware.fr/hfr/Achat [...] 1897_1.htm

evilbrood

petit up !

J'ai résolu le problème de réception COM, j'ai rajouté une condition sur le premier octet recu (si il vaut bien 0x01 on continue à lire, sinon on réessaie), et ça fonctionne !!

Du coup il ne me reste plus qu'un problème à régler dans mon projet, c'est à dire pouvoir envoyer la trame reçue (une fois convertie) via le port Ethernet.
Pour l'instant ça fonctionne (du moins en local, je n'ai pas testé entre deux PCs), mais le problème est le même que pour le port série.
L'envoi se fait sur le click d'un bouton, et tant que le client ne s'est pas connecté, le programme est bloqué.

Par contre cette fois je ne pense pas pouvoir contourner le problème avec un timer, vu que pour envoyer la trame j'utilise la fonction suivante :
csock = accept(..., ..., .......);
qui elle est bloquante.

Donc à moins de pouvoir utiliser une fonction non bloquante qui ferait à peu près la même chose, je vais devoir utiliser les threads ?
Mais je suis un peu perdu, je ne vois pas vraiment quelles fonctions utiliser, pthreat_create() et pthread_join() ???

---------------
Mon topic de ventes matos informatique : http://forum.hardware.fr/hfr/Achat [...] 1897_1.htm

Farian

Bonjour !

Effectivement, la fonction "accept" est bloquante, mais la fonction "select" permet de résoudre le problème, car elle permet de savoir si il y a un client en attente sur la "listening socket" (celle sur laquelle vous faites le accept).

Lors de l'appel, vous rajoutez le "file descriptor" de la socket dans le paramètre "readfs" et si un client est en attente, la socket est marquée comme ayant des données à lire, et vous pouvez lancer l'appel "accept" qui rendra la main tout de suite.

Publicité

evilbrood

Merci pour ta réponse, ça m'a pas mal aidé quand j'en avais besoin.

Finalement, j'ai du utiliser les threads, et au final c'est pas si compliqué que ça, il faut faire gaffe et bien savoir ce que l'on fait mais ça va tout seul !

---------------
Mon topic de ventes matos informatique : http://forum.hardware.fr/hfr/Achat [...] 1897_1.htm

FORUM HardWare.fr

Programmation

Lecture port com vc++, sans blocage ?

Sujets relatifs
Lecture, insertion/création fichier	Lecture des articles de mon blog horizontalement.
blocage sur mon programme	Lecture de fichier
pb subi de lecture de mp3, barre de boutons out, compatibilité embed?	Lire port série C# et convertir en texte
Question sur lecture fichier	explication et lecture d'un fichier binaire(C3D)
Lecture de fichiers binaires [résolu]	problème réception port série.
Plus de sujets relatifs à : Lecture port com vc++, sans blocage ?

Page générée en 0.138 secondes