Sujet Précédent Sujet Suivant

Aide pour un programme,création variable

cs_pirana Messages postés 17 Date d'inscription dimanche 8 juin 2003 Statut Membre Dernière intervention 16 juin 2005 - 11 avril 2005 à 15:35
ymca2003 Messages postés 2070 Date d'inscription mardi 22 avril 2003 Statut Membre Dernière intervention 3 juillet 2006 - 12 avril 2005 à 09:07
bonjour à vous tous ... Voila je suis un débutant en C... j'ai récupéré ce code sur le site et j'aimerai me simplifié la vie...mais je n'y arrive pas c'est pour cela que je fais appel à vous ...
Je m'explique : ce code permet d'envoyer ou de recevoir une trame à travers un RS232 ...
Ce que j'aimerai faire c'est crée une variable qui me permetterai d'envoyer un caractère ou une chaine de caractère plus simplement, que de travailler avec gets(buffer)
un truc du style :
Je veux envoyer '04'
send='04';
et ca me fait tt le traitement d'un coup

Car j'aimertai envoyé un octet de Start et un de stop en fonction du menu dans lequel on rentre

J'espère avoir été assez clair , si ce nest po le cas ... contacté moi

MERCI


Code :

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

4 réponses

Réponse 1 / 4
ymca2003 Messages postés 2070 Date d'inscription mardi 22 avril 2003 Statut Membre Dernière intervention 3 juillet 2006 7
11 avril 2005 à 17:36
BYTE buffer[32];
buffer[0] = 0x12;
buffer[1] = 0x34;
...
buffer[len-1] = 0x56; (len <= 32)
WriteCOM(buffer, len, &nBytesWritten);

pour envoyer un seul octet :
BYTE b = 0x45;
WriteCOM(&b, 1, &nBytesWritten);
0
Réponse 2 / 4
cs_Arnotic Messages postés 933 Date d'inscription dimanche 1 avril 2001 Statut Membre Dernière intervention 9 janvier 2012
11 avril 2005 à 17:42
De plus sur le site tu as de multiples exemples complets :

http://www.cppfrance.com/gma/rs223

@+
Arnotic,
Admin CS, MVP Visual C++
0
Réponse 3 / 4
cs_pirana Messages postés 17 Date d'inscription dimanche 8 juin 2003 Statut Membre Dernière intervention 16 juin 2005
11 avril 2005 à 19:02
merci à toi ymca2003 :



mais je n'est pas tt compris dans ton code ... tu pourrais m'expliqué un peu plus ..



BYTE buffer[32]; // Définition du type de buffer ... (est ce compatible avec mon autre déclaration de buffer )
buffer[0] = 0x12;
buffer[1] = 0x34;
...
buffer[len-1] = 0x56; (len <= 32) // questque "len" pour envoyer un serie d'octet ?
WriteCOM(buffer, len, &nBytesWritten);

pour envoyer un seul octet :
BYTE b = 0x45;
WriteCOM(&b, 1, &nBytesWritten);



Question ??

Estceque je peux déclarer plusieur buffer du style ..



BYTE buffer[32];


char buffer_reception[256];



buffer[len-1] = 0x56; (len <= 32)
WriteCOM(buffer, len, &nBytesWritten);




WriteCOM(
buffer_reception
, len, &nBytesWritten);




merci
0
Réponse 4 / 4
ymca2003 Messages postés 2070 Date d'inscription mardi 22 avril 2003 Statut Membre Dernière intervention 3 juillet 2006 7
12 avril 2005 à 09:07
BYTE : il s'agit en fait du type unsigned char soit en fait des octets non signés, c'est ce qu'il y a de plus simple pour des buffers contenant du binaire.
Avec la fct WriteCOM on peut envoyer n'importe quoi (un buffer, une chaîne, un entier, une structure...) vu que le type est void* (pointeur sur tout et n'importe quoi). Il suffit de bien précisé le nombre d'octets (strlen pour les chaîne, sizeof pour des structures...)

'len' est en fait une variable pour stocker la longueur (lenght in english, sorry c'est par habitude) du buffer (j'ai mis <= 32 car il y a 32 octets dans le buffer que j'ai déclaré)
0

Discussions similaires

Utilisation de douchette et creation des codes barres VB6
INFORMATIQUE01 -
INFORMATIQUE01 -

3 réponses
Base de données ou API pour programme TV
cs_azerty25 -
ucfoutu -

4 réponses
Outlook Message : Un programme tente d'envoyer un message en votre nom .... Com
cs_GigaCool -
nvoisn -

9 réponses
Desactivation du bouton mode creation
mikmak78 -
ucfoutu -

11 réponses
Erreur 91 "Variable objet ou bloc with non définie" ???????
doomVB -
crenaud76 -

3 réponses
Rejoignez-nous