[C] Lecteur port série windows.h (readFile()) + SDL

Lecteur port série windows.h (readFile()) + SDL [C] - C - Programmation

Marsh Posté le 20-11-2011 à 19:09:48    

Bonjour,
 
Pour un de mes projets, je réalise un script utilisant la SDL, et lisant des données issues d'un de mes ports série (envoyées par une carte arduino). Or, il semble qu'il est ait un conflit entre la SDL et les fonctions telles que readFile().
 
Voici mon code sans mon code du main afin qu'il soit moins lourd :
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <conio.h>
  4. #include <string.h>
  5. #include <windows.h>
  6. #include <SDL/SDL.h>
  9. #define RX_SIZE     500000   /* taille tampon d'entrée  */
  10. #define TX_SIZE     500000   /* taille tampon de sortie */
  11. #define MAX_WAIT_READ   2500  /* temps max d'attente pour lecture (en ms) */
  13. HANDLE g_hCOM = NULL;
  15. COMMTIMEOUTS g_cto =
  16. {
  17.   MAX_WAIT_READ,  /* ReadIntervalTimeOut      */
  18.   0,        /* ReadTotalTimeOutMultiplier   */
  19.   MAX_WAIT_READ,  /* ReadTotalTimeOutConstant   */
  20.   0,        /* WriteTotalTimeOutMultiplier  */
  21.   0         /* WriteTotalTimeOutConstant  */
  22. };
  24. /* Configuration du port COM */
  25. DCB g_dcb =
  26. {
  27.   sizeof(DCB),    /* DCBlength      */
  28.   9600,         /* BaudRate       */
  29.   TRUE,         /* fBinary        */
  30.   FALSE,        /* fParity        */
  31.   FALSE,        /* fOutxCtsFlow     */
  32.   FALSE,        /* fOutxDsrFlow     */
  33.   DTR_CONTROL_ENABLE, /* fDtrControl      */
  34.   FALSE,        /* fDsrSensitivity    */
  35.   FALSE,        /* fTXContinueOnXoff  */
  36.   FALSE,        /* fOutX        */
  37.   FALSE,        /* fInX         */
  38.   FALSE,        /* fErrorChar       */
  39.   FALSE,        /* fNull        */
  40.   RTS_CONTROL_ENABLE, /* fRtsControl      */
  41.   FALSE,        /* fAbortOnError    */
  42.   0,          /* fDummy2        */
  43.   0,          /* wReserved      */
  44.   0x100,        /* XonLim         */
  45.   0x100,        /* XoffLim        */
  46.   8,          /* ByteSize       */
  47.   NOPARITY,       /* Parity         */
  48.   ONESTOPBIT,     /* StopBits       */
  49.   0x11,         /* XonChar        */
  50.   0x13,         /* XoffChar       */
  51.   '?',        /* ErrorChar      */
  52.   0x1A,         /* EofChar        */
  53.   0x10        /* EvtChar        */
  54. };
  56. BOOL OpenCOM  (int nId);
  57. BOOL CloseCOM   ();
  58. BOOL ReadCOM  (void* buffer, int nBytesToRead, int* pBytesRead);
  59. void pause();
  61. int main(int argc, char *argv[]){
  62.   SDL_Init(SDL_INIT_VIDEO); // Initialisation de la SDL
  64.   SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE); // Ouverture de la fenêtre
  66.   pause(); // Mise en pause du programme
  68.   SDL_Quit(); // Arrêt de la SDL
  70.   return EXIT_SUCCESS; // Fermeture du programme
  71. }
  73. BOOL OpenCOM(int nId){
  74.   /* variables locales */
  75.   char szCOM[16];
  77.   /* construction du nom du port, tentative d'ouverture */
  78.   sprintf(szCOM, "COM%d", nId);
  79.   g_hCOM = CreateFile(szCOM, GENERIC_READ|GENERIC_WRITE, 0, NULL,
  80.             OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL);
  81.   if(g_hCOM == INVALID_HANDLE_VALUE){
  82.     printf("Erreur lors de l'ouverture du port COM%d", nId);
  83.     return FALSE;
  84.   }
  86.   /* affectation taille des tampons d'émission et de réception */
  87.   SetupComm(g_hCOM, RX_SIZE, TX_SIZE);
  89.   /* configuration du port COM */
  90.   if(!SetCommTimeouts(g_hCOM, &g_cto) || !SetCommState(g_hCOM, &g_dcb)){
  91.     printf("Erreur lors de la configuration du port COM%d", nId);
  92.     CloseHandle(g_hCOM);
  93.     return FALSE;
  94.   }
  96.   /* on vide les tampons d'émission et de réception, mise à 1 DTR */
  97.   PurgeComm(g_hCOM, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
  98.   EscapeCommFunction(g_hCOM, SETDTR);
  99.   return TRUE;
  100. }
  102. BOOL CloseCOM(){
  103.   /* fermeture du port COM */
  104.   CloseHandle(g_hCOM);
  105.   return TRUE;
  106. }
  108. BOOL ReadCOM(void* buffer, int nBytesToRead, int* pBytesRead){
  109.   return ReadFile(g_hCOM, buffer, nBytesToRead, pBytesRead, NULL);
  110. }
  112. void pause()
  113. {
  114.   int continuer = 1;
  115.   SDL_Event event;
  117.   while (continuer){
  118.     SDL_WaitEvent(&event);
  119.     switch(event.type){
  120.       case SDL_QUIT:
  121.         continuer = 0;
  122.     }
  123.   }
  124. }


 
Lorsque que je n'utilise pas la SDL, aucun problème, mais quand je l'utilise, il m'empêche d'utiliser cette fonction
Voici mon erreur :
 
http://www.legeekcafe.com/upload/img/1297error.PNG

Reply

Marsh Posté le 20-11-2011 à 19:09:48   

Reply

Marsh Posté le 20-11-2011 à 20:38:41    

Bonsoir,
 
L'erreur est pourtant claire. Le compilateur te dit qu'il ne peut pas convertir int * en DWORD *. Il faut donc que tu changes le prototype de ta fonction ReadCOM en utilisant un DWORD * plutot qu'un int * pour le 3eme paramètre.

Reply

Marsh Posté le 23-11-2011 à 15:22:24    

Salut,
 
j'ai trouvé beaucoup mieux que ça. Mon code est en C++. Je le passe en C, et je n'ai plus besoin de convertir

Reply

Marsh Posté le 21-04-2012 à 14:35:31    

Bonjour,
 
Je tente de réaliser un programme en C qui envoi et recoit des données via un port série. Cependant je ne trouve rien qui m'aide vraiment sur internet.  
fab@c++ pourrait tu poster ton code afin que je puisse voir un exemple qui fonctionne ?
 
Merci.

Reply

Marsh Posté le 21-04-2012 à 15:22:40    

Salut,
 
Mon code récupère une chaîne qu'il stocke dans un fichier texte. Voici le genre de chaîne que je récupère via le port série :
 

Code :
  1. 111111111111111111111111111111111111111111111111 196 202 179 255 1111111111111111111111111111111111111111111111111111111111111111111111 197 201 181 255 1111111111111111111111111111111111111111111111


 
Et voici mon code c++ . Attention, il possède une partie SDL. Si t'as des questions, n'hésite pas à poster
 

Code :
  1. #include <conio.h>
  2. #include <string.h>
  3. #include <windows.h>
  4. #include <SDL/SDL.h>
  5. #define RX_SIZE 16000
  6. #define TX_SIZE 16000
  7. #define MAX_WAIT_READ 1000
  9. HANDLE g_hCOM = NULL;
  11. COMMTIMEOUTS g_cto ={
  12.   MAX_WAIT_READ,0,MAX_WAIT_READ,0,0
  13. };
  15. DCB g_dcb ={
  16.   sizeof(DCB),9600,TRUE,FALSE,FALSE,FALSE,DTR_CONTROL_ENABLE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE,RTS_CONTROL_ENABLE,FALSE,0,0,0x100,0x100,8,NOPARITY,ONESTOPBIT,0x11,0x13,'?',0x1A,0x10
  17. };
  19. BOOL OpenCOM  (int nId);
  20. BOOL CloseCOM   ();
  21. static BOOL ReadCOM  (void* buffer, int nBytesToRead, int* pBytesRead);
  23. int main(int argc, char *argv[]){
  24.   //SDL ici
  25.   SDL_Surface *ecran = NULL, *rectangle_1 = NULL, *rectangle_2 = NULL, *rectangle_3 = NULL, *rectangle_4 = NULL;
  26.   SDL_Rect position_1, position_2, position_3, position_4;
  27.   SDL_Init(SDL_INIT_VIDEO);
  28.   ecran = SDL_SetVideoMode(480,480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF );
  29.   rectangle_1 = SDL_CreateRGBSurface(SDL_HWSURFACE, 240,240, 32, 0, 0, 0, 0);
  30.   rectangle_2 = SDL_CreateRGBSurface(SDL_HWSURFACE, 240,240, 32, 0, 0, 0, 0);
  31.   rectangle_3 = SDL_CreateRGBSurface(SDL_HWSURFACE, 240,240, 32, 0, 0, 0, 0);
  32.   rectangle_4 = SDL_CreateRGBSurface(SDL_HWSURFACE, 240,240, 32, 0, 0, 0, 0);
  33.   position_1.x = 0; position_1.y = 240;
  34.   position_2.x = 240; position_2.y = 240;
  35.   position_3.x = 0; position_3.y = 0;
  36.   position_4.x = 240; position_4.y = 0;
  37.   SDL_WM_SetCaption("electronic eye", NULL);
  38.   //fin SDL
  40.   static const unsigned short int nId=4; //relatif à l'affichage
  41.   static unsigned char buffer[200]; //le buffer qui contient la chaîne récupérée via le port série
  42.   static int nBytesRead;
  43.   static unsigned short int i=0;
  44.   static unsigned short int sensor[10] = {0};
  45.   static unsigned char sensor_1[1];
  46.   static unsigned char sensor_3[]="1111111111 ";
  47.   FILE *fichier = NULL;
  49.   if(!OpenCOM(nId)) return -1;
  51.   while(1) { //boucle de la SDL
  52.     if(ReadCOM(buffer, sizeof(buffer)-2, &nBytesRead)){ //ON lit le port série
  53.       buffer[nBytesRead] = '\0';
  55.       fichier = fopen("test.txt", "w+" );  //on enregistre dans le fichier
  57.       fputs(buffer, fichier);
  58.       fclose(fichier);
  60.       fichier = fopen("test.txt", "r+" );
  62.       if (fichier != NULL){  // on récupère et on affiche
  63.         fscanf(fichier, "%s %d %d %d %d", &sensor_1[0], &sensor[0], &sensor[1], &sensor[2], &sensor[3]);
  64.         fclose(fichier);
  66.         if(sensor[0]>255 || sensor[0]<0 || sensor[0]==111) sensor[0]=((sensor[1]+sensor[2]+sensor[3])/3);
  67.         if(sensor[1]>255 || sensor[1]<0 || sensor[1]==111) sensor[1]=((sensor[0]+sensor[2]+sensor[3])/3);
  68.         if(sensor[2]>255 || sensor[2]<0 || sensor[2]==111) sensor[2]=((sensor[1]+sensor[0]+sensor[3])/3);
  69.         if(sensor[3]>255 || sensor[3]<0 || sensor[3]==111) sensor[3]=((sensor[1]+sensor[2]+sensor[0])/3);
  71.         SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, sensor[0],sensor[0],sensor[0]));
  72.         SDL_FillRect(rectangle_1, NULL, SDL_MapRGB(ecran->format, sensor[0],sensor[0],sensor[0]));
  73.         SDL_BlitSurface(rectangle_1, NULL, ecran, &position_1);
  74.         SDL_FillRect(rectangle_2, NULL, SDL_MapRGB(ecran->format, sensor[1],sensor[1],sensor[1]));
  75.         SDL_BlitSurface(rectangle_2, NULL, ecran, &position_2);
  76.         SDL_FillRect(rectangle_3, NULL, SDL_MapRGB(ecran->format, sensor[2],sensor[2],sensor[2]));
  77.         SDL_BlitSurface(rectangle_3, NULL, ecran, &position_3);
  78.         SDL_FillRect(rectangle_4, NULL, SDL_MapRGB(ecran->format, sensor[3],sensor[3],sensor[3]));
  79.         SDL_BlitSurface(rectangle_4, NULL, ecran, &position_4);
  81.         SDL_Flip(ecran);
  82.       }
  83.     }
  84.     i++;
  85.   }
  86.   CloseCOM();
  87.   SDL_Quit();
  88.   return 0;
  89. }
  91. BOOL OpenCOM(int nId){
  92.   char szCOM[16];
  94.   sprintf(szCOM, "COM%d", nId);
  95.   g_hCOM = CreateFile(szCOM, GENERIC_READ|GENERIC_WRITE, 0, NULL,
  96.             OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL);
  97.   if(g_hCOM == INVALID_HANDLE_VALUE){
  98.     printf("Erreur lors de l'ouverture du port COM%d", nId);
  99.     return FALSE;
  100.   }
  102.   SetupComm(g_hCOM, RX_SIZE, TX_SIZE);
  104.   if(!SetCommTimeouts(g_hCOM, &g_cto) || !SetCommState(g_hCOM, &g_dcb)){
  105.     printf("Erreur lors de la configuration du port COM%d", nId);
  106.     CloseHandle(g_hCOM);
  107.     return FALSE;
  108.   }
  110.   PurgeComm(g_hCOM, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
  111.   EscapeCommFunction(g_hCOM, SETDTR);
  112.   return TRUE;
  113. }
  115. BOOL CloseCOM(){
  116.   CloseHandle(g_hCOM);
  117.   return TRUE;
  118. }
  120. static BOOL ReadCOM(void* buffer, int nBytesToRead, int* pBytesRead){
  121.   return ReadFile(g_hCOM, buffer, nBytesToRead, pBytesRead, NULL);
  122. }

Reply

Marsh Posté le 21-04-2012 à 15:41:44    

Merci pour ton code, je suis débutante en C et n'y connais pas grand chose, c'est donc un peu compliquer pour moi...
 
Je suis en stage et je cherche à communiquer via les ports séries de windows avec un calibrateur et un multimètre, je voudrais donc pouvoir à la fois lire et écrire sur les ports. Je dois envoyer des commandes du type "MEAS?" pour que l'appareil me revoie la valeur mesurée.
En attendant de trouver une solution pour utiliser les port séries directement en c j'utilise l'hyperterminal que j'ouvre avec mon programme et ou j'écris virtuellement des commandes, mais cette solution me semble un peu lourde puisqu'elle nécessite l'ouverture de plusieurs fenêtres.  
Pourrait tu m'expliquer à quoi sert la SDL.
Si je comprend bien il me suffit de retirer tout ce qui concerne la SDL pour pouvoir utiliser les ports séries ?  
 
Merci d'avance pour votre aide.

Reply

Marsh Posté le 21-04-2012 à 19:04:01    

Mon programme avait pour but d'afficher un écran à partir de données récupérées par des capteurs d'une carte arduino. La SDL sert juste à l'affichage. On peut donc enlever toutes les partie relatives à l'affichage en SDL pour pouvoir exécuter ce programme en mode console.
Pour ma part, j'ai beaucoup cherché pour la lecture sur le port, mais je ne sais pas trop comment écrire. je pense, ce code utilisant la lib windows.h, qu'il suffit de s'intéresser à cette lib pour s'avoir comment écrire sur un port série.
 
Voilà :)

Reply

Marsh Posté le 21-04-2012 à 20:19:03    

Merci de ta réponse je vais essayer et ca, et te tiens au courant du résultat ;-)

Reply

Marsh Posté le 22-04-2012 à 16:48:42    

J'ai fait des tests du coup mais je rencontre un problème.
J'ai ajouter la partie écriture que j'ai trouvé sur le net faite sur le même modèle que ta partie lecture, mais quand j'envoi des données au calibrateur et il ne semble pas les recevoir, de même pour la lecture, il ne renvoi rien. J'ai vérifier les paramètres baudrate, databits, stopbit qui sont bon mais je ne sais pas a quoi correspondent les autres.
Quel compilateur utilisais tu ? Peut tu me dire à quoi sert le "static" tout a la fin pour la lecture du port ?

Reply

Sujets relatifs:

Leave a Replay

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