Lecture port com vc++, sans blocage ?

Lecture port com vc++, sans blocage ? - C - Programmation

Marsh Posté le 23-07-2012 à 15:44:10    

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 :
  1. int nBytesRead=0, nBytesMessageRecu = 0, tailleMessageCOM=0;
  2. char charBuffer[1024], IP[16] = "127.0.0.1";
  3. int j, portSophie;
  4. BOOL COM_SOPHIE2 = FALSE;
  5. unsigned char message_conv_KLV[MAX_TEXT_KLV], recept_COM[TAILLE_MAX_COM];
  6. klv_icd ^ klv_icd2 = gcnew klv_icd();
  7. portCOM ^ portCOM2 = gcnew portCOM();
  9. portSophie = (int)NUM_PORT_COM->Value;
  10. TIM_COM->Enabled = 1;
  12. // Lecture des deux premiers octets de la trame afin de récupérer la taille de la trame
  13. while(nBytesMessageRecu < 2) {
  14. if(portCOM2->COM_Sophie == 0){
  15.  if(portCOM2->OpenSophie(portSophie)){
  16.   portCOM2->COM_Sophie = TRUE;
  17.   this->TXT_ETAT_COM->Text = "Connexion OK !";
  18.  }
  19.  else this->TXT_ETAT_COM->Text = "No Connection !";
  20. }
  21. if(portCOM2->COM_Sophie) if(portCOM2->ReadSophie(charBuffer, 1, &nBytesRead) == 0) portCOM2->COM_Sophie = FALSE;
  22.  nBytesMessageRecu = 0;
  23.  if(portCOM2->COM_Sophie){
  24.  if(nBytesRead){
  25.   while(nBytesMessageRecu < 2) {
  26.    if(nBytesMessageRecu < 2) recept_COM[nBytesMessageRecu] = (unsigned char) charBuffer[0];
  27.    nBytesMessageRecu++;
  28.    portCOM2->ReadSophie(charBuffer, 1, &nBytesRead);
  29.   }
  30.  }
  31. }
  32. }
  33. recept_COM[nBytesMessageRecu] = (unsigned char) charBuffer[0];
  34. nBytesMessageRecu = 0;
  36. //Lecture des octets restants
  37. while((nBytesMessageRecu + 3) < (recept_COM[1] + 4)) {
  38. if(!portCOM2->COM_Sophie) if(portCOM2->OpenSophie(portSophie)) portCOM2->COM_Sophie = TRUE;
  39. if(portCOM2->COM_Sophie) if(!portCOM2->ReadSophie(charBuffer, 1, &nBytesRead)) portCOM2->COM_Sophie = FALSE;
  40.  nBytesMessageRecu = 0;
  41. if(portCOM2->COM_Sophie){
  42.  if(nBytesRead){
  43.   while(nBytesRead) {
  44.    if((nBytesMessageRecu + 3) < (recept_COM[1] + 4)) recept_COM[nBytesMessageRecu+3] = (unsigned char) charBuffer[0];
  45.    nBytesMessageRecu++;
  46.    portCOM2->ReadSophie(charBuffer, 1, &nBytesRead);
  47.   }
  48.  }
  49. }
  50. }
  51. portCOM2->CloseSophie();
  53. //affichage de la trame reçue
  54. ...
  55. ...
  56. ...


 
 
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
Reply

Marsh Posté le 23-07-2012 à 15:44:10   

Reply

Marsh Posté le 23-07-2012 à 16:37:44    

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 :
  1. // creation port
  3. HANDLE serial_handle = CreateFile(buf, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING , FILE_FLAG_OVERLAPPED  , NULL);
  5. // creation event  
  7. OVERLAPPED overlap_read_evt;
  9. memset(&overlap_read_evt, 0, sizeof(overlap_read_evt));
  10. overlap_read_evt.hEvent =  CreateEvent(NULL,TRUE,FALSE,NULL);
  13. // ecoute sur le port  
  15. DWORD event_mask;
  16. event_mask = EV_RXCHAR;
  17. WaitCommEvent( serial_handle , &event_mask, &overlap_read_evt); // attache l event au handle , a réarmer à chaque appel
  18. DWORD retwait = WaitForSingleObject(overlap_read_evt.hEvent, 1000); // attend 1000 ms  s'il s'est passé quelque chose  
  20. if (retwait == WAIT_OBJECT_0)
  21. { // recu des données
  22. ResetEvent(overlap_read_evt.hEvent);
  23. ReadFile( serial_handle, mybuffer , mybuffersize, (DWORD*)&mybytesread, &overlap_read_evt) == 0);
  24. }
  25. else if (retwait == WAIT_TIMEOUT)
  26. { // rien recu
  28. }
  29. else if (retwait == WAIT_FAILED)
  30. { // erreur
  32. }
  34. // fermeture
  36. CloseHandle( overlap_read_evt.hEvent );
  37. CloseHandle( serial_handle );


Reply

Marsh Posté le 23-07-2012 à 17:44:22    

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
Reply

Marsh Posté le 24-07-2012 à 15:54:41    

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

Code :
  1. int portCOM::LectureCOM(unsigned char* buffer, int portCOM, int mybuffersize){
  4. /* Délais d'attente sur le port COM Sophie */
  5. COMMTIMEOUTS g_ctoSophie = {
  6.  MAX_WAIT_READ_SOPHIE, /* ReadIntervalTimeOut */
  7.  0, /* ReadTotalTimeOutMultiplier */
  8.  MAX_WAIT_READ_SOPHIE, /* ReadTotalTimeOutConstant */
  9.  0, /* WriteTotalTimeOutMultiplier */
  10.  0 /* WriteTotalTimeOutConstant */
  11. };
  13. /* Configuration du port COM Sophie */
  14. DCB g_dcbSophie = {
  15.   sizeof(DCB), /* DCBlength */
  16.   115200, /* BaudRate */ //115200
  17.   TRUE, /* fBinary */
  18.   TRUE, /* fParity */
  19.   FALSE, /* fOutxCtsFlow */
  20.   FALSE, /* fOutxDsrFlow */
  21.   DTR_CONTROL_ENABLE, /* fDtrControl */
  22.   FALSE, /* fDsrSensitivity */
  23.   FALSE, /* fTXContinueOnXoff */
  24.   FALSE, /* fOutX */
  25.   FALSE, /* fInX */
  26.   FALSE, /* fErrorChar */
  27.   FALSE, /* fNull */
  28.   RTS_CONTROL_ENABLE, /* fRtsControl */
  29.   FALSE, /* fAbortOnError */
  30.   0, /* fDummy2 */
  31.   0, /* wReserved */
  32.   0x100, /* XonLim */
  33.   0x100, /* XoffLim */
  34.   8, /* ByteSize */
  35.   ODDPARITY, /* Parity */
  36.   ONESTOPBIT, /* StopBits */
  37.   //ONESTOPBIT, //DEBUG
  38.   0x11, /* XonChar */
  39.   0x13, /* XoffChar */
  40.   '?', /* ErrorChar */
  41.   0x1A, /* EofChar */
  42.   0x10 /* EvtChar */
  43. };
  45. char szCOM[16], charBuffer[1024];
  46. int result, nBytesMessageRecu = 0;
  47. int* nBytesRead = 0;
  49. OVERLAPPED overlap_read_evt;
  50. sprintf(szCOM, "\\\\.\\COM%d", portCOM);
  52. HANDLE h_sophie2 = CreateFile(szCOM, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
  53. if (h_sophie2 == INVALID_HANDLE_VALUE) result = 1;
  55.  /* affectation taille des tampons d'émission et de réception */
  56.     SetupComm(h_sophie2, RX_SIZE, TX_SIZE);
  58.     /* configuration du port COM */
  59.     if(!SetCommTimeouts(h_sophie2, &g_ctoSophie) || !SetCommState(h_sophie2, &g_dcbSophie)){
  60.         result = 2;
  61. }
  63.     /* on vide les tampons d'émission et de réception, mise à 1 DTR */
  64.     PurgeComm(h_sophie2, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
  65.     EscapeCommFunction(h_sophie2, SETDTR);
  67. memset(&overlap_read_evt, 0, sizeof(overlap_read_evt));
  68. overlap_read_evt.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  70. DWORD event_mask;
  71. event_mask = EV_RXCHAR;
  72. WaitCommEvent(h_sophie2, &event_mask, &overlap_read_evt);
  73. DWORD retwait = WaitForSingleObject(overlap_read_evt.hEvent, 6000);
  75. if (retwait == WAIT_OBJECT_0){
  76.  ResetEvent(overlap_read_evt.hEvent);
  77.  // Lecture des deux premiers octets de la trame afin de récupérer la taille de la trame
  78.  while(nBytesMessageRecu < 2) {
  80.   nBytesMessageRecu = 0;
  82.   if(nBytesRead){
  83.    while(nBytesMessageRecu < 2) {
  84.     if(nBytesMessageRecu < 2) buffer[nBytesMessageRecu] = (unsigned char) charBuffer[0];
  85.     nBytesMessageRecu++;
  86.     ReadFile(h_sophie2, charBuffer, 1, (DWORD*)&nBytesRead, &overlap_read_evt);
  87.    }
  88.   }
  90.  }
  91.  buffer[nBytesMessageRecu] = (unsigned char) charBuffer[0];
  92.  nBytesMessageRecu = 0;
  94.  //Lecture des octets restants
  95.  while((nBytesMessageRecu + 3) < (buffer[1] + 4)) {
  97.   nBytesMessageRecu = 0;
  98.   if(nBytesRead){
  99.    while(nBytesRead) {
  100.     if((nBytesMessageRecu + 3) < (buffer[1] + 4)) buffer[nBytesMessageRecu+3] = (unsigned char) charBuffer[0];
  101.     nBytesMessageRecu++;
  102.     ReadFile(h_sophie2, charBuffer, 1, (DWORD*)&nBytesRead, &overlap_read_evt);
  103.    }
  104.   }
  105.  }
  106. }
  107. else if (retwait == WAIT_TIMEOUT){
  108.  result = 5;
  109. }
  110. CloseHandle(overlap_read_evt.hEvent);
  111. CloseHandle(h_sophie2);
  112. return result;
  113. }


 
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
Reply

Marsh Posté le 24-07-2012 à 16:19:15    

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 ...
 

Reply

Marsh Posté le 25-07-2012 à 11:29:17    

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 :
  1. public ref class Form1 : public System::Windows::Forms::Form
  2. {
  3. public:
  4.  Form1(void)
  5.  {
  6.   InitializeComponent();
  7.   //
  8.   //TODO: ajoutez ici le code du constructeur
  9.   //
  10.  }
  11.  //Déclaration des variables à cet endroit ??
  12. protected:
  13.  /// <summary>
  14.  /// Nettoyage des ressources utilisées.
  15.  /// </summary>
  16.  ~Form1()
  17.  {
  18.   if (components)
  19.   {
  20.    delete components;
  21.   }
  22.  }


 
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
Reply

Marsh Posté le 25-07-2012 à 14:48:49    

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
Reply

Marsh Posté le 25-07-2012 à 15:38:35    

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 :
  1. int nBytesRead=0, nBytesMessageRecu = 0, tailleMessageCOM=0;
  2. char charBuffer[1024];
  3. int j, portSophie;
  4. BOOL COM_SOPHIE2 = FALSE, COM_RECEIVED = FALSE;
  5. unsigned char recept_COM[TAILLE_MAX_COM];
  6. klv_icd ^ klv_icd2 = gcnew klv_icd();
  7. portCOM ^ portCOM2 = gcnew portCOM();
  9. portSophie = (int)NUM_PORT_COM->Value;
  11. if(!COM_SOPHIE2) if(portCOM2->OpenSophie(portSophie)){
  12.  COM_SOPHIE2 = TRUE;
  13.  TXT_ETAT_COM->Text = "Connexion OK";
  14. }
  15. else TXT_ETAT_COM->Text = "No Connection";
  16. if(COM_SOPHIE2) if(!portCOM2->ReadSophie(charBuffer, 1, &nBytesRead)){
  17.  COM_SOPHIE2 = FALSE;
  18.  portCOM2->CloseSophie();
  19. }
  21. nBytesMessageRecu = 0;
  23. if(COM_SOPHIE2){
  24.  if(nBytesRead){
  25.   while(nBytesMessageRecu < 2) {
  26.    if(nBytesMessageRecu < 2) recept_COM[nBytesMessageRecu] = (unsigned char) charBuffer[0];
  27.    nBytesMessageRecu++;
  28.    portCOM2->ReadSophie(charBuffer, 1, &nBytesRead);
  29.   }
  30.  }
  31. }
  33. recept_COM[nBytesMessageRecu] = (unsigned char) charBuffer[0];
  34. nBytesMessageRecu = 0;
  36. //Lecture des octets restants
  37. if(!COM_SOPHIE2) if(portCOM2->OpenSophie(portSophie)) COM_SOPHIE2 = TRUE;
  38. if(COM_SOPHIE2) if(!portCOM2->ReadSophie(charBuffer, 1, &nBytesRead)) COM_SOPHIE2 = FALSE;
  40. nBytesMessageRecu = 0;
  41. if(COM_SOPHIE2){
  42.  if(nBytesRead){
  43.   while(nBytesRead) {
  44.    if((nBytesMessageRecu + 3) < (recept_COM[1] + 4)) recept_COM[nBytesMessageRecu+3] = (unsigned char) charBuffer[0];
  45.    nBytesMessageRecu++;
  46.    portCOM2->ReadSophie(charBuffer, 1, &nBytesRead);
  47.    COM_RECEIVED = TRUE;
  48.   }
  49.  }
  50. }
  51. portCOM2->CloseSophie();
  53. if(COM_RECEIVED){
  55.  //affichage de la trame reçue
  56.  .....
  58.  //Lecture de la trame - extraction des coordonnées
  59.  if(klv_icd2->extractFields(recept_COM, recept_COM[1] + 4, &reponseSophie) == 1){
  61.   //Affichage des coordonnées
  62.   ....
  64.   //Conversion en KLV
  65.   klv_icd2->reponseToKLV(reponseSophie, message_conv_KLV);
  67.   //Affichage des cooronnées en KLV
  68.   ....
  69.  }
  70. }


 
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
Reply

Marsh Posté le 26-07-2012 à 12:56:59    

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
Reply

Marsh Posté le 27-07-2012 à 08:21:11    

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.

Reply

Marsh Posté le 27-07-2012 à 08:21:11   

Reply

Marsh Posté le 01-08-2012 à 14:16:52    

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
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed