[RS232]Besoin d'aide super urgente

Besoin d'aide super urgente [RS232] - C - Programmation

Marsh Posté le 25-10-2007 à 09:49:21    

Salut à tous,  
 
Je suis en BTS IRIS, et j'ai un mini projet sur 2 jours à réaliser...
 
Je dispose d'une douchette code barres reliée en RS232 et je souhaiterais tout simplement obtenir le code nécessaire pour récupérer les caractères sur le pc,par exemple dans notepad....Ce programme doit etre en C.(je dispose de Borland C++ Builder 6)
 
J'ai cherché durant une demi journée sur le net, galérer sur mon pc pendant un bon moment, je viens maintenant me confier à vous....
 
J'espere que vous pourrez m'aider un peu...
 
Merci!


Message édité par moustic74 le 25-10-2007 à 10:22:37
Reply

Marsh Posté le 25-10-2007 à 09:49:21   

Reply

Marsh Posté le 25-10-2007 à 09:50:58    

C'est quoi la question ? [:petrus dei]

Reply

Marsh Posté le 25-10-2007 à 09:51:58    

t foutu :O

Reply

Marsh Posté le 25-10-2007 à 09:52:17    

Euh, oué j'ai zappé...Comment faire pour recupérer sur le pc le code barre ( pas les barres, mais les numéros et caractères qui y sont liés)?????
Ou si quelqu'un à un petit programme qui permettrait de lire l'input du port COM1, j'suis preneur....merki!!

Reply

Marsh Posté le 25-10-2007 à 09:55:25    

Donc en gros, tu demandes un code tout fait pour pouvoir rendre ton sujet dans les temps ? Tu n'as rien écrit ?

Reply

Marsh Posté le 25-10-2007 à 09:56:19    

Si si j'ai écrit, mais ca marche pas..enfin, je me suis " inspiré d'un code sur cppfrance ou un site du genre..

Reply

Marsh Posté le 25-10-2007 à 09:57:27    

/******************************************************************************
TestCOM.c :
fonctions de base pour l'envoi et la réception de donner sur un port
série RS232.
******************************************************************************/
*
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
*

Spoiler :


/*=============================================================================
Définition de constantes
=============================================================================*/
#define RX_SIZE 4096 / taille tampon d'entrée */
#define TX_SIZE 4096 / taille tampon de sortie */
#define MAX_WAIT_READ 5000 / temps max d'attente pour lecture (en ms) */
/*=============================================================================
Variables globales.
=============================================================================*/
/* Handle du port COM ouvert */
HANDLE g_hCOM = NULL;
 
/* Délais d'attente sur le port COM */
COMMTIMEOUTS g_cto =
{
  MAX_WAIT_READ, /* ReadIntervalTimeOut */
  0, /* ReadTotalTimeOutMultiplier */
  MAX_WAIT_READ, /* ReadTotalTimeOutConstant */
  0, /* WriteTotalTimeOutMultiplier */
  0 /* WriteTotalTimeOutConstant */
  };
 
/* Configuration du port COM */
DCB g_dcb =
{
  sizeof(DCB), /* DCBlength */
  9600, /* BaudRate */
  TRUE, /* fBinary */
  FALSE, /* 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 */
  NOPARITY, /* Parity */
  ONESTOPBIT, /* StopBits */
  0x11, /* XonChar */
  0x13, /* XoffChar */
  '?', /* ErrorChar */
  0x1A, /* EofChar */
  0x10 /* EvtChar */
};
 
/*=============================================================================
Fonctions du module.
=============================================================================*/
BOOL OpenCOM (int nId);
BOOL CloseCOM ();
BOOL ReadCOM (void buffer, int nBytesToRead, int pBytesRead);
BOOL WriteCOM (void buffer, int nBytesToWrite, int pBytesWritten);
 
/******************************************************************************
main : point d'entrée du programme.
******************************************************************************/
int main()
{
/* variables locales */
char buffer[256];
int nId, nChoice, nBytesWritten, nBytesRead;
 
/* demande du numéro du port COM */
printf("Entrez le numero du port COM : " );
scanf("%d", &nId);
 
     /* tentative d'ouverture */
     printf("Ouverture et configuration du port COM%d...\r\n", nId);
     if(!OpenCOM(nId)) return -1;
     printf("...OK\r\n" );
 
     /* boucle tant que l'on ne quitte pas */
     do
     {
     /* menu */
     printf("\r\n" );
     printf("1 : Recevoir des donnees.\r\n" );
     printf("2 : Quitter.\r\n" );
     printf("Choix : " );
     scanf("%d", &nChoice);
 
 
 
     /* recevoir des données */
     if(nChoice == 2)
     {
     printf("\r\n" );
     printf("Reception de donnees...\r\n" );
     if(ReadCOM(buffer, sizeof(buffer)-1, &nBytesRead))
     {
     buffer[nBytesRead] = '\0';
     printf("%d octet(s) recu(s) :\r\n%s\r\n", nBytesRead, buffer);
     }
     else
     printf("Erreur lors de la réception.\r\n" );
     }
     }while(nChoice != 3);
 
     /* fermeture du port COM et retour */
     CloseCOM();
     return 0;
     }
 
     /******************************************************************************
     OpenCOM : ouverture et configuration du port COM.
     entrée : nId : Id du port COM à ouvrir.
     retour : vrai si l'opération a réussi, faux sinon.
     ******************************************************************************/
     BOOL OpenCOM(int nId)
     {
     /* variables locales */
     char szCOM[16];
 
     /* construction du nom du port, tentative d'ouverture */
     sprintf(szCOM, "COM%d", nId);
     g_hCOM = CreateFile(szCOM, GENERIC_READ|GENERIC_WRITE, 0, NULL,
     OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL);
     if(g_hCOM == INVALID_HANDLE_VALUE)
     {
     printf("Erreur lors de l'ouverture du port COM%d", nId);
     return FALSE;
     }
 
     /* affectation taille des tampons d'émission et de réception */
     SetupComm(g_hCOM, RX_SIZE, TX_SIZE);
 
     /*configuration du port COM */
     if(!SetCommTimeouts(g_hCOM, &g_cto) || !SetCommState(g_hCOM, &g_dcb))
     {
     printf("Erreur lors de la configuration du port COM%d", nId);
     CloseHandle(g_hCOM);
     return FALSE;
     }
 
     /* on vide les tampons d'émission et de réception, mise à 1 DTR */
     PurgeComm(g_hCOM, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
     EscapeCommFunction(g_hCOM, SETDTR);
     return TRUE;
     }
 
     /******************************************************************************
     CloseCOM : fermeture du port COM.
     retour : vrai si l'opération a réussi, faux sinon.
     ******************************************************************************/
     BOOL CloseCOM()
     {
     /* fermeture du port COM */
     CloseHandle(g_hCOM);
     return TRUE;
     }
 
     /******************************************************************************
     ReadCOM : lecture de données sur le port COM.
     entrée : buffer : buffer où mettre les données lues.
     nBytesToRead : nombre max d'octets à lire.
     pBytesRead : variable qui va recevoir le nombre d'octets lus.
     retour : vrai si l'opération a réussi, faux sinon.
     -------------------------------------------------------------------------------
     Remarques : - la constante MAX_WAIT_READ utilisée dans la structure
     COMMTIMEOUTS permet de limiter le temps d'attente si aucun
     caractères n'est présent dans le tampon d'entrée.
     - la fonction peut donc retourner vrai sans avoir lu de données.
     ******************************************************************************/
     BOOL ReadCOM(void buffer, int nBytesToRead, int pBytesRead)
     {
     return ReadFile(g_hCOM, buffer, nBytesToRead, pBytesRead, NULL);
     }
 
 
}
//---------------------------------------------------------------------------

Reply

Marsh Posté le 25-10-2007 à 09:57:45    

oups

Reply

Marsh Posté le 25-10-2007 à 09:59:57    

C'est mieux [:klem3i1]
 
De mon côté je n'ai pas ce qu'il faut pour tester sur ma plateforme (je bosse sous *nix), peux-tu nous préciser ce qui ne fonctionne pas ?
 
(essaie d'utiliser les balises [cpp][/cpp] pour encadrer ton code et le rendre lisible dans le forum ;) )

Reply

Marsh Posté le 25-10-2007 à 10:00:13    

Il te reste plus qu'a debugay :D

Reply

Marsh Posté le 25-10-2007 à 10:00:13   

Reply

Marsh Posté le 25-10-2007 à 10:10:42    

oué alors:
 
au début j'avais une erreur d'entete précompilé, que j'ai corrigé.
ensuite,une autre erreur (fatale cette fois )dans stdio.h, où j'avais un souci avec un truc du genre: std {
 
mais ca ne marche pas, et du coup, j'ai 26 erreurs... :'(

Reply

Marsh Posté le 25-10-2007 à 10:20:38    

tu es dans la cat C++ :D pas C

Reply

Marsh Posté le 25-10-2007 à 10:21:49    

BenO, dsl jme suis planté....C'est trop speed pour moi en ce moment, donc j'ai pas fais gaffe...

Reply

Marsh Posté le 25-10-2007 à 10:22:08    

Y'a un moyen de changer de catégorie, maintenant que le sujet est posté?

Reply

Marsh Posté le 25-10-2007 à 10:22:53    

C'est bon j'ai changé de catégories...

Reply

Marsh Posté le 25-10-2007 à 10:24:26    

il manque un bout de ton code (en haut) dans la balise :x

Reply

Marsh Posté le 25-10-2007 à 10:26:53    

tes commentaires ne sont pas valides:
 
#define RX_SIZE 4096 / taille tampon d'entrée */
#define TX_SIZE 4096 / taille tampon de sortie */
#define MAX_WAIT_READ 5000 / temps max d'attente pour lecture (en ms) */  
 
/ taille tampon d'entrée */ -> /* taille tampon d'entrée */

Reply

Marsh Posté le 25-10-2007 à 10:27:49    

BOOL ReadCOM (void buffer, int nBytesToRead, int pBytesRead);
BOOL WriteCOM (void buffer, int nBytesToWrite, int pBytesWritten);

 

type void, ca veut rien dire >.<

 

void* à la limite.

 


je ne sais pas ce que tu as foutu avec tes *  BOUDIOU


Message édité par BenO le 25-10-2007 à 10:28:23
Reply

Marsh Posté le 25-10-2007 à 10:34:06    

lol j'ai copié collé le code en fait...Ca ma rajouté plein de * partout...Et comme un boulet, j'ai fait remplacer * par " " (rien) et du coup, ca ma niké tt les commentaires....
 
 
Et comme un boul**, j'arrive pas a retrouver le site ou y'avai le code..

Reply

Marsh Posté le 25-10-2007 à 10:35:06    

Attends un peu, tu veux dire que ce code-là n'est absolument pas de toi ?
En gros tu nous demandes de t'aider à corriger un code que tu as recopié d'un autre site, après que tu aies remplacé toutes les "*" par rien ?


Message édité par Elmoricq le 25-10-2007 à 10:35:43
Reply

Marsh Posté le 25-10-2007 à 10:35:28    

MON DIEU >.<  
 
ca compile :D mais ya aucune raison que ca marche ^^ j'ai pas testé.
et j'ai corrigé ca àlaporky :x  
 
tu peux faire un WinMerge sur les deux versions pour voir ce que j'ai modifié.
 
 
bonne chance jim.
 

Code :
  1. /******************************************************************************
  2. TestCOM.c :
  3. fonctions de base pour l'envoi et la réception de donner sur un port
  4. série RS232.
  5. ******************************************************************************/
  6. #include <windows.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <conio.h>
  10. /*=============================================================================
  11. Définition de constantes
  12. =============================================================================*/
  13. #define RX_SIZE 4096 /* taille tampon d'entrée */
  14. #define TX_SIZE 4096 /* taille tampon de sortie */
  15. #define MAX_WAIT_READ 5000 /* temps max d'attente pour lecture (en ms) */
  16. /*=============================================================================
  17. Variables globales.
  18. =============================================================================*/
  19. /* Handle du port COM ouvert */
  20. HANDLE g_hCOM = NULL;
  21. /* Délais d'attente sur le port COM */
  22. COMMTIMEOUTS g_cto =
  23. {
  24.     MAX_WAIT_READ, /* ReadIntervalTimeOut */
  25.     0, /* ReadTotalTimeOutMultiplier */
  26.     MAX_WAIT_READ, /* ReadTotalTimeOutConstant */
  27.     0, /* WriteTotalTimeOutMultiplier */
  28.     0 /* WriteTotalTimeOutConstant */
  29. };
  30. /* Configuration du port COM */
  31. DCB g_dcb =
  32. {
  33.     sizeof(DCB), /* DCBlength */
  34.     9600, /* BaudRate */
  35.     TRUE, /* fBinary */
  36.     FALSE, /* fParity */
  37.     FALSE, /* fOutxCtsFlow */
  38.     FALSE, /* fOutxDsrFlow */
  39.     DTR_CONTROL_ENABLE, /* fDtrControl */
  40.     FALSE, /* fDsrSensitivity */
  41.     FALSE, /* fTXContinueOnXoff */
  42.     FALSE, /* fOutX */
  43.     FALSE, /* fInX */
  44.     FALSE, /* fErrorChar */
  45.     FALSE, /* fNull */
  46.     RTS_CONTROL_ENABLE, /* fRtsControl */
  47.     FALSE, /* fAbortOnError */
  48.     0, /* fDummy2 */
  49.     0, /* wReserved */
  50.     0x100, /* XonLim */
  51.     0x100, /* XoffLim */
  52.     8, /* ByteSize */
  53.     NOPARITY, /* Parity */
  54.     ONESTOPBIT, /* StopBits */
  55.     0x11, /* XonChar */
  56.     0x13, /* XoffChar */
  57.     '?', /* ErrorChar */
  58.     0x1A, /* EofChar */
  59.     0x10 /* EvtChar */
  60. };
  61. /*=============================================================================
  62. Fonctions du module.
  63. =============================================================================*/
  64. BOOL OpenCOM (int nId);
  65. BOOL CloseCOM ();
  66. BOOL ReadCOM (void* buffer, int nBytesToRead, int& pBytesRead);
  67. BOOL WriteCOM (void* buffer, int nBytesToWrite, int& pBytesWritten);
  68. /******************************************************************************
  69. main : point d'entrée du programme.
  70. ******************************************************************************/
  71. int main()
  72. {
  73.     /* variables locales */
  74.     char buffer[256];
  75.     int nId, nChoice, nBytesWritten, nBytesRead;
  76.     /* demande du numéro du port COM */
  77.     printf("Entrez le numero du port COM : " );
  78.     scanf("%d", &nId);
  79.     /* tentative d'ouverture */
  80.     printf("Ouverture et configuration du port COM%d...\r\n", nId);
  81.     if(!OpenCOM(nId)) return -1;
  82.     printf("...OK\r\n" );
  83.     /* boucle tant que l'on ne quitte pas */
  84.     do
  85.     {
  86.         /* menu */
  87.         printf("\r\n" );
  88.         printf("1 : Recevoir des donnees.\r\n" );
  89.         printf("2 : Quitter.\r\n" );
  90.         printf("Choix : " );
  91.         scanf("%d", &nChoice);
  92.         /* recevoir des données */
  93.         if(nChoice == 2)
  94.         {
  95.             printf("\r\n" );
  96.             printf("Reception de donnees...\r\n" );
  97.             if(ReadCOM(buffer, sizeof(buffer)-1, nBytesRead))
  98.             {
  99.                 buffer[nBytesRead] = '\0';
  100.                 printf("%d octet(s) recu(s) :\r\n%s\r\n", nBytesRead, buffer);
  101.             }
  102.             else
  103.                 printf("Erreur lors de la réception.\r\n" );
  104.         }
  105.     }while(nChoice != 3);
  106.     /* fermeture du port COM et retour */
  107.     CloseCOM();
  108.     return 0;
  109. }
  110. /******************************************************************************
  111. OpenCOM : ouverture et configuration du port COM.
  112. entrée : nId : Id du port COM à ouvrir.
  113. retour : vrai si l'opération a réussi, faux sinon.
  114. ******************************************************************************/
  115. BOOL OpenCOM(int nId)
  116. {
  117.     /* variables locales */
  118.     char szCOM[16];
  119.     /* construction du nom du port, tentative d'ouverture */
  120.     sprintf(szCOM, "COM%d", nId);
  121.     g_hCOM = CreateFile(szCOM, GENERIC_READ|GENERIC_WRITE, 0, NULL,
  122.         OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL);
  123.     if(g_hCOM == INVALID_HANDLE_VALUE)
  124.     {
  125.         printf("Erreur lors de l'ouverture du port COM%d", nId);
  126.         return FALSE;
  127.     }
  128.     /* affectation taille des tampons d'émission et de réception */
  129.     SetupComm(g_hCOM, RX_SIZE, TX_SIZE);
  130.     /*configuration du port COM */
  131.     if(!SetCommTimeouts(g_hCOM, &g_cto) || !SetCommState(g_hCOM, &g_dcb))
  132.     {
  133.         printf("Erreur lors de la configuration du port COM%d", nId);
  134.         CloseHandle(g_hCOM);
  135.         return FALSE;
  136.     }
  137.     /* on vide les tampons d'émission et de réception, mise à 1 DTR */
  138.     PurgeComm(g_hCOM, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
  139.     EscapeCommFunction(g_hCOM, SETDTR);
  140.     return TRUE;
  141. }
  142. /******************************************************************************
  143. CloseCOM : fermeture du port COM.
  144. retour : vrai si l'opération a réussi, faux sinon.
  145. ******************************************************************************/
  146. BOOL CloseCOM()
  147. {
  148.     /* fermeture du port COM */
  149.     CloseHandle(g_hCOM);
  150.     return TRUE;
  151. }
  152. /******************************************************************************
  153. ReadCOM : lecture de données sur le port COM.
  154. entrée : buffer : buffer où mettre les données lues.
  155. nBytesToRead : nombre max d'octets à lire.
  156. pBytesRead : variable qui va recevoir le nombre d'octets lus.
  157. retour : vrai si l'opération a réussi, faux sinon.
  158. -------------------------------------------------------------------------------
  159. Remarques : - la constante MAX_WAIT_READ utilisée dans la structure
  160. COMMTIMEOUTS permet de limiter le temps d'attente si aucun
  161. caractères n'est présent dans le tampon d'entrée.
  162. - la fonction peut donc retourner vrai sans avoir lu de données.
  163. ******************************************************************************/
  164. BOOL ReadCOM(void* buffer, int nBytesToRead, int& pBytesRead)
  165. {
  166.     return ReadFile(g_hCOM, buffer, nBytesToRead, (LPDWORD)pBytesRead, NULL);
  167. }
  168. //---------------------------------------------------------------------------

Reply

Marsh Posté le 25-10-2007 à 10:42:07    

Je vais tester, mais je suis pas sur que ca marche....J'ai pas tout copié, juste des fractions ou je galérais...

Reply

Marsh Posté le 25-10-2007 à 10:43:34    

Comment je peux faire pour vous exposer d'un coup l'ensemble des erreurs?Ca crée un fichier log ou pas?

Reply

Marsh Posté le 25-10-2007 à 10:45:21    

j'ai corrigé toutes les erreurs que j'avais sur le bout de source :x
Je vais pas te corriger 500 lignes de code ^^
 
Essaye de comprendre les erreurs, fais une recherche sur google
avec l'erreur et regarde des forums sur lesquelles elle serait résolue :x

Reply

Marsh Posté le 25-10-2007 à 10:48:55    

Oué ok,j'ai déja fait ca un peu, mais je désespere lol...
Allez j'y retourne un moment...++

Reply

Marsh Posté le 25-10-2007 à 10:50:26    

Derniere petite question: il me dit que j'ai une erreur la dessus
dans stdio.h...

Code :
  1. #ifdef __cplusplus
  2. namespace std {
  3. #endif /* __cplusplus */
 

Erreur de syntaxe de déclaration...


Message édité par moustic74 le 25-10-2007 à 10:50:50
Reply

Marsh Posté le 25-10-2007 à 13:45:13    

Ca y est, ca marche presque...J'ai réussi à faire en sorte que le programme marche, mais j'ai un méchant plantage au moment de faire l'acquisition des données...Borland C se plante,mon prog est inactif...ctrl+Alt+Suppr est la seule solution....Il me dit :  
 
Violation d'accès à l'adresse 00401808.Ecriture de l'adresse 327DE368.
 
Ca me parait bizarre...Je ne sais pas à quoi correspond l'adresse 327DE368...
 
Quelqu'un sait comment remédier à ce message d'erreur?Et à quoi correspond cette adresse mémoire?
 
Merci beaucoup pour votre patience à mon égard...

Reply

Marsh Posté le 26-10-2007 à 13:44:21    

moustic74 a écrit :


/******************************************************************************
TestCOM.c :
fonctions de base pour l'envoi et la réception de donner sur un port
série RS232.
******************************************************************************/



Il manquait un tas de '*' ... Ceci compile (Code::Blocks / MinGW)...

Code :
  1. /******************************************************************************
  2. TestCOM.c :
  3. fonctions de base pour l'envoi et la réception de donner sur un port
  4. série RS232.
  5. ******************************************************************************/
  6. #include <windows.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <conio.h>
  10. /*=============================================================================
  11. Définition de constantes
  12. =============================================================================*/
  13. #define RX_SIZE 4096            /* taille tampon d'entrée */
  14. #define TX_SIZE 4096            /* taille tampon de sortie */
  15. #define MAX_WAIT_READ 5000      /* temps max d'attente pour lecture (en ms) */
  16. /*=============================================================================
  17. Variables globales.
  18. =============================================================================*/
  19. /* Handle du port COM ouvert */
  20. HANDLE g_hCOM = NULL;
  21. /* Délais d'attente sur le port COM */
  22. COMMTIMEOUTS g_cto = {
  23.    MAX_WAIT_READ,               /* ReadIntervalTimeOut */
  24.    0,                           /* ReadTotalTimeOutMultiplier */
  25.    MAX_WAIT_READ,               /* ReadTotalTimeOutConstant */
  26.    0,                           /* WriteTotalTimeOutMultiplier */
  27.    0                            /* WriteTotalTimeOutConstant */
  28. };
  29. /* Configuration du port COM */
  30. DCB g_dcb = {
  31.    sizeof (DCB),                /* DCBlength */
  32.    9600,                        /* BaudRate */
  33.    TRUE,                        /* fBinary */
  34.    FALSE,                       /* fParity */
  35.    FALSE,                       /* fOutxCtsFlow */
  36.    FALSE,                       /* fOutxDsrFlow */
  37.    DTR_CONTROL_ENABLE,          /* fDtrControl */
  38.    FALSE,                       /* fDsrSensitivity */
  39.    FALSE,                       /* fTXContinueOnXoff */
  40.    FALSE,                       /* fOutX */
  41.    FALSE,                       /* fInX */
  42.    FALSE,                       /* fErrorChar */
  43.    FALSE,                       /* fNull */
  44.    RTS_CONTROL_ENABLE,          /* fRtsControl */
  45.    FALSE,                       /* fAbortOnError */
  46.    0,                           /* fDummy2 */
  47.    0,                           /* wReserved */
  48.    0x100,                       /* XonLim */
  49.    0x100,                       /* XoffLim */
  50.    8,                           /* ByteSize */
  51.    NOPARITY,                    /* Parity */
  52.    ONESTOPBIT,                  /* StopBits */
  53.    0x11,                        /* XonChar */
  54.    0x13,                        /* XoffChar */
  55.    '?',                         /* ErrorChar */
  56.    0x1A,                        /* EofChar */
  57.    0x10,                        /* EvtChar */
  58.    0,                           /* reserved 1 */
  59. };
  60. /* **************************************************************************
  61.    OpenCOM : ouverture et configuration du port COM.
  62.    entrée : nId : Id du port COM à ouvrir.
  63.    retour : vrai si l'opération a réussi, faux sinon.
  64.    ************************************************************************** */
  65. BOOL OpenCOM (int nId)
  66. {
  67.    /* variables locales */
  68.    char szCOM[16];
  69.    /* construction du nom du port, tentative d'ouverture */
  70.    sprintf (szCOM, "COM%d", nId);
  71.    g_hCOM = CreateFile (szCOM, GENERIC_READ | GENERIC_WRITE, 0, NULL,
  72.                         OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL);
  73.    if (g_hCOM == INVALID_HANDLE_VALUE)
  74.    {
  75.       printf ("Erreur lors de l'ouverture du port COM%d", nId);
  76.       return FALSE;
  77.    }
  78.    /* affectation taille des tampons d'émission et de réception */
  79.    SetupComm (g_hCOM, RX_SIZE, TX_SIZE);
  80.    /*configuration du port COM */
  81.    if (!SetCommTimeouts (g_hCOM, &g_cto) || !SetCommState (g_hCOM, &g_dcb))
  82.    {
  83.       printf ("Erreur lors de la configuration du port COM%d", nId);
  84.       CloseHandle (g_hCOM);
  85.       return FALSE;
  86.    }
  87.    /* on vide les tampons d'émission et de réception, mise à 1 DTR */
  88.    PurgeComm (g_hCOM,
  89.               PURGE_TXCLEAR | PURGE_RXCLEAR | PURGE_TXABORT | PURGE_RXABORT);
  90.    EscapeCommFunction (g_hCOM, SETDTR);
  91.    return TRUE;
  92. }
  93. /* **************************************************************************
  94.    CloseCOM : fermeture du port COM.
  95.    retour : vrai si l'opération a réussi, faux sinon.
  96.    ************************************************************************** */
  97. BOOL CloseCOM (void)
  98. {
  99.    /* fermeture du port COM */
  100.    CloseHandle (g_hCOM);
  101.    return TRUE;
  102. }
  103. /* **************************************************************************
  104.    ReadCOM : lecture de données sur le port COM.
  105.    entrée : buffer : buffer où mettre les données lues.
  106.    nBytesToRead : nombre max d'octets à lire.
  107.    pBytesRead : variable qui va recevoir le nombre d'octets lus.
  108.    retour : vrai si l'opération a réussi, faux sinon.
  109.    --------------------------------------------------------------------------
  110.    Remarques : - la constante MAX_WAIT_READ utilisée dans la structure
  111.    COMMTIMEOUTS permet de limiter le temps d'attente si aucun
  112.    caractères n'est présent dans le tampon d'entrée.
  113.    - la fonction peut donc retourner vrai sans avoir lu de données.
  114.    ************************************************************************** */
  115. BOOL ReadCOM (void *buffer, long nBytesToRead, long *pBytesRead)
  116. {
  117.    return ReadFile (g_hCOM, buffer, nBytesToRead, pBytesRead, NULL);
  118. }
  119. /* **************************************************************************
  120.    main : point d'entrée du programme.
  121.    ************************************************************************** */
  122. int main (void)
  123. {
  124.    int nId;
  125.    int nChoice;
  126. /* demande du numéro du port COM */
  127.    printf ("Entrez le numero du port COM : " );
  128.    scanf ("%d", &nId);
  129.    /* tentative d'ouverture */
  130.    printf ("Ouverture et configuration du port COM%d...\n", nId);
  131.    if (!OpenCOM (nId))
  132.       return -1;
  133.    printf ("...OK\r\n" );
  134.    /* boucle tant que l'on ne quitte pas */
  135.    do
  136.    {
  137.       /* menu */
  138.       printf ("\r\n" );
  139.       printf ("1 : Recevoir des donnees.\n" );
  140.       printf ("2 : Quitter.\r\n" );
  141.       printf ("Choix : " );
  142.       scanf ("%d", &nChoice);
  143.       /* recevoir des données */
  144.       if (nChoice == 2)
  145.       {
  146.          char buffer[256];
  147.          long size = sizeof (buffer) - 1;
  148.          long nBytesRead = 0;
  149.          printf ("\r\n" );
  150.          printf ("Reception de donnees...\n" );
  151.          if (ReadCOM (buffer, size, &nBytesRead))
  152.          {
  153.             buffer[nBytesRead] = '\0';
  154.             printf ("%ld octet(s) recu(s) :\n'%s'\n", nBytesRead, buffer);
  155.          }
  156.          else
  157.          {
  158.             printf ("Erreur lors de la réception.\n" );
  159.          }
  160.       }
  161.    }
  162.    while (nChoice != 3);
  163.    /* fermeture du port COM et retour */
  164.    CloseCOM ();
  165.    return 0;
  166. }


... mais je n'ai pas de port COM sur ma machine (portable, désolé).


Entrez le numero du port COM : 1
Ouverture et configuration du port COM1...
Erreur lors de l'ouverture du port COM1
Press ENTER to continue.

 


Message édité par Emmanuel Delahaye le 26-10-2007 à 13:45:09

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

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