Com RS232

Signaler
Messages postés
3
Date d'inscription
mercredi 11 mai 2011
Statut
Membre
Dernière intervention
6 juin 2011
-
Messages postés
3
Date d'inscription
mercredi 11 mai 2011
Statut
Membre
Dernière intervention
6 juin 2011
-
Bonjour,

Actuellement je cherche à récupérer une trame via la liaison RS232, je réussi très bien à faire ce que je veux à l'aide d'hyperterminal, c'est à dire que je capture la trame et l'envoi dans un fichier txt.

Ce que j'aimerai faire c'est lancer au démarrage de l'ordi un programme qui scrute le port série et chaque fois qu'une trame arrive (elle fait 67octets) on vient réécrire par dessus mon fichier texte.

Je pense que c'est assez simple à réaliser pour quelqu'un de compétent mais n'ayant jamais fait de programmation en langage C sa me parait irréalisable.

J'ai parcouru un peu toutes les discussions abordant ce sujet, et récupéré un code se rapportant à ce que j'essaye de faire après quelque modif sur celui ci je suis coincé au niveau de la réception de ma trame en effet je ne sais pas comment laisser le prog attendre une nouvelle trame et réécrire par dessus mon fichier txt.
J'utilise dev C++ encore une fois je ne sais pas si c'est le plus simple pour quelqu'un n'ayant jamais programmé.

Si jamais quelqu'un aurai une piste je lui en serait reconnaissant.

Cordialement.

Le bout de code :

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

/*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 20000 /* 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 */
1200, /* 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);

/******************************************************************************
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("0 : Quitter.\r\n");
printf("Choix : ");
scanf("%d", &nChoice);

/* recevoir des données */
if(nChoice == 1)
{
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 != 0);

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

3 réponses

Messages postés
3
Date d'inscription
mercredi 11 mai 2011
Statut
Membre
Dernière intervention
6 juin 2011

A priori mon histoire n'intéresse pas grand monde dommage
Messages postés
792
Date d'inscription
mardi 8 juillet 2003
Statut
Membre
Dernière intervention
12 juillet 2019
8
Bonjour,

excuse-nous de ne pas avoir classer ta demande prioritaire;-)
Je pense qu'il faut que tu mettes une tâche sur la réception après l'ouverture et dans cette tâche tu écris dans un fichier.
Je n'utilise pas DevC++ mais visual studio.
Voilà la classe que j'utilise :
http://www.codeproject.com/KB/system/serial.aspx

Mais il y en a d'autres sur ce site. Il faut chercher.

louis
Messages postés
3
Date d'inscription
mercredi 11 mai 2011
Statut
Membre
Dernière intervention
6 juin 2011

Merci de ta réponse Louis j'ai réussi a mettre mes données dans un fichier le problème c'est qu'elles ne se mettent dedans qu'une fois que j'ai fermé le programme sinon elle reste dans le buffer. Comment faire pour éviter sa ?
Merci.