Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1688 connectés 

  FORUM HardWare.fr
  Programmation
  C

  [RS232]Besoin d'aide super urgente

 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

[RS232]Besoin d'aide super urgente

n°1630672
moustic74
Posté le 25-10-2007 à 09:49:21  profilanswer
 

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
mood
Publicité
Posté le 25-10-2007 à 09:49:21  profilanswer
 

n°1630674
Elmoricq
Modérateur
Posté le 25-10-2007 à 09:50:58  profilanswer
 

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

n°1630676
BenO
Profil: Chercheur
Posté le 25-10-2007 à 09:51:58  profilanswer
 

t foutu :O

n°1630677
moustic74
Posté le 25-10-2007 à 09:52:17  profilanswer
 

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

n°1630679
Elmoricq
Modérateur
Posté le 25-10-2007 à 09:55:25  profilanswer
 

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

n°1630681
moustic74
Posté le 25-10-2007 à 09:56:19  profilanswer
 

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

n°1630683
moustic74
Posté le 25-10-2007 à 09:57:27  profilanswer
 

/******************************************************************************
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);
     }
 
 
}
//---------------------------------------------------------------------------

n°1630684
moustic74
Posté le 25-10-2007 à 09:57:45  profilanswer
 

oups

n°1630689
Elmoricq
Modérateur
Posté le 25-10-2007 à 09:59:57  profilanswer
 

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 ;) )

n°1630690
BenO
Profil: Chercheur
Posté le 25-10-2007 à 10:00:13  profilanswer
 

Il te reste plus qu'a debugay :D

mood
Publicité
Posté le 25-10-2007 à 10:00:13  profilanswer
 

n°1630698
moustic74
Posté le 25-10-2007 à 10:10:42  profilanswer
 

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... :'(

n°1630706
BenO
Profil: Chercheur
Posté le 25-10-2007 à 10:20:38  profilanswer
 

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

n°1630707
moustic74
Posté le 25-10-2007 à 10:21:49  profilanswer
 

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

n°1630708
moustic74
Posté le 25-10-2007 à 10:22:08  profilanswer
 

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

n°1630710
moustic74
Posté le 25-10-2007 à 10:22:53  profilanswer
 

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

n°1630711
BenO
Profil: Chercheur
Posté le 25-10-2007 à 10:24:26  profilanswer
 

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

n°1630713
BenO
Profil: Chercheur
Posté le 25-10-2007 à 10:26:53  profilanswer
 

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 */

n°1630714
BenO
Profil: Chercheur
Posté le 25-10-2007 à 10:27:49  profilanswer
 

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
n°1630719
moustic74
Posté le 25-10-2007 à 10:34:06  profilanswer
 

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

n°1630722
Elmoricq
Modérateur
Posté le 25-10-2007 à 10:35:06  profilanswer
 

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
n°1630723
BenO
Profil: Chercheur
Posté le 25-10-2007 à 10:35:28  profilanswer
 

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

n°1630728
moustic74
Posté le 25-10-2007 à 10:42:07  profilanswer
 

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

n°1630731
moustic74
Posté le 25-10-2007 à 10:43:34  profilanswer
 

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

n°1630734
BenO
Profil: Chercheur
Posté le 25-10-2007 à 10:45:21  profilanswer
 

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

n°1630735
moustic74
Posté le 25-10-2007 à 10:48:55  profilanswer
 

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

n°1630738
moustic74
Posté le 25-10-2007 à 10:50:26  profilanswer
 

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
n°1630871
moustic74
Posté le 25-10-2007 à 13:45:13  profilanswer
 

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

n°1631594
Emmanuel D​elahaye
C is a sharp tool
Posté le 26-10-2007 à 13:44:21  profilanswer
 

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/
mood
Publicité
Posté le   profilanswer
 


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  [RS232]Besoin d'aide super urgente

 

Sujets relatifs
Étant novice, j'ai besoin d'assistance pour ce scripteBesoin d aide en php et MySQL
aide msdos quelques problemesbesion aide optimisation php mysql
[php] Besoin d'aide fonctions vers classesAide en VB script svp
Perte de focus clavier inexpliqué, aide bienvenue !Aide programme Jeu : Devinez le bon chiffre
Plus de sujets relatifs à : [RS232]Besoin d'aide super urgente


Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR