Comment forcer le RTS pour une liaison RS232 [Résolu]

cs_ancat 20 Messages postés mardi 20 juillet 2004Date d'inscription 1 septembre 2004 Dernière intervention - 9 août 2004 à 17:20 - Dernière réponse : ymca2003 2070 Messages postés mardi 22 avril 2003Date d'inscription 3 juillet 2006 Dernière intervention
- 18 août 2004 à 21:53
Bonjour
je viens de faire un petit prog (grandement inspire de sources du site) mais je ne saisis pas trop le controle du RTS.

Celui ci est-il traite par le système?

Existe-t-il une commande permettant de forcer le RTS comme pour le DTR?

Merci d'avance.

PS:
Voici mon code si quelquechose vous choque n'hesitez pas dites le moi
/******************************************************************************
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 300 /* taille tampon d'entrée */
#define TX_SIZE 300 /* taille tampon de sortie */
#define MAX_WAIT_READ 40 /* temps max d'attente pour lecture (en ms) */

#define COM1 1
/*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 */
TRUE, /* 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 */
EVENPARITY, /* Parity */
ONESTOPBIT, /* StopBits */
0x11, /* XonChar */
0x13, /* XoffChar */
'?', /* ErrorChar */
0x1A, /* EofChar */
0x10 /* EvtChar */
};

unsigned char ptr_buffer[128];/*Fonctions du module.*/
BOOL OpenCOM (int nId);
BOOL CloseCOM ();
BOOL ReadCOM (void* buffer, int nBytesToRead, unsigned long* pBytesRead);
BOOL WriteCOM (void* buffer, int nBytesToWrite, unsigned long* pBytesWritten);
int verif_octets(unsigned char *ptr_buf);
int lecture();
int ecriture();
int checksum(int lec_ecr);
unsigned char binary_code(int nombre,unsigned char *tampon);
int emet(int nombre,unsigned char *buffer,unsigned long* nBytesWritten);
int acquiert(int nombre,unsigned char *buffer,unsigned long* nBytesRead);
int initialisation(void);

/******************************************************************************
main : point d'entrée du programme.
******************************************************************************/
int main()
{
/* variables locales */

int nId, nChoice;

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

/* envoyer des données */
if(nChoice == 1)
{
printf("\r\n");

ecriture();
}

/* lire des données */
if(nChoice == 2)
{
printf("\r\n");

lecture();
}

}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, unsigned long* pBytesRead)
{
return ReadFile(g_hCOM, buffer, nBytesToRead, pBytesRead,NULL);
}

/******************************************************************************
WriteCOM : envoi de données sur le port COM.
entrée : buffer : buffer avec les données à envoyer.
nBytesToWrite : nombre d'octets à envoyer.
pBytesWritten : variable qui va recevoir le nombre d'octets
envoyés.
retour : vrai si l'opération a réussi, faux sinon.
******************************************************************************/
BOOL WriteCOM(void* buffer, int nBytesToWrite, unsigned long* pBytesWritten)
{
/* écriture sur le port */
return WriteFile(g_hCOM, buffer, nBytesToWrite, pBytesWritten,NULL);
}

/**************************************************************
Lecture de 128 octets avec protocole de communication Balluff *
***************************************************************/
int lecture()
{
int erreur,fin=0,compteur1=0;
unsigned long nBytesRead,nBytesWritten;
unsigned char data_recu[3];
unsigned char BCC[11]="R00000128Y";
unsigned char STX[1]={2};
unsigned char ptr_buffer[128];

// erreur=initialisation();

//emission d'une commande
erreur=emet(10,BCC,&nBytesWritten);

//acquisition d'un accuse de reception
erreur=acquiert(2,data_recu,&nBytesRead);
printf("nombre de bits lus %d acquisition de ACK : %s\n",nBytesRead,data_recu);

//Si l'on a un ACK
if(data_recu[0]==6)
{
//On envoie le STX
erreur=emet(1,STX,&nBytesWritten);

//On recupere les donnees
erreur=acquiert(128,ptr_buffer,&nBytesRead); //mettre ici ptr_buffer en global

//On controle par le calcul du checksum
erreur=checksum(0);
}
return 1;
}

/**************************************************************
Ecriture de 128 octets avec protocole de communication Balluff
***************************************************************/
int ecriture()
{
int erreur,fin=0,compteur1=0;
unsigned long nBytesRead,nBytesWritten;
unsigned char data_recu[3];
unsigned char test[3];
unsigned char resultat[3];

unsigned char STX[1]={2};
unsigned char commande[11]="W00000128";
unsigned char ptr_buffer[130]="123456789012345678901234567890123456789012134567890123456789012345678901234567890123456789012345678901234567890123456789012345678";
unsigned char a_emettre[130];

//Place le checksum
checksum(1);
*a_emettre=STX[0];
for(int i=0;i<128;i++) *(a_emettre+i+1)=*(ptr_buffer+i);

//Place le BCC en fin de message
*(a_emettre+129)=binary_code(129,a_emettre);

commande[9]=binary_code(10,commande);

//initialisation du boitier
erreur=initialisation();

//Emission de la commande d'ecriture
erreur=emet(10,commande,&nBytesWritten);

//probleme lors de la seconde acquisition
//Acquisition de l accuse de reception (validation de la commande)
erreur=acquiert(2,test,&nBytesRead);

printf("nombre de bits lus %d acquisition de ACK : %s\n",nBytesRead,test);

//Si on recoit bien ACK
if(test[0]==6)
{
// printf("lecture effectuee");
//On envoie le STX + les données + BCC
erreur=emet(130,a_emettre,&nBytesWritten);

//On recupere l'accuse de reception
erreur=acquiert(2,resultat,&nBytesRead);
printf("nombre de bits lus %d acquisition de ACK : %s\n",nBytesRead,resultat);
if(resultat[0]==21) printf("ERREUR");
if(resultat[0]==6) printf("ca marche?");
}
else
{
compteur1++;
if(compteur1==3)
{
//Mettre ici l'erreur
//Impossible d'établir une communication
//return
}
}

return 1;
}

int checksum(int lec_ecr)
{
/*
si lec_ecr est à 0, on est en lecture
si lec_ecr est à 1, on est en ecriture
*/

unsigned int sum,i,A=256,temp;
unsigned int sum_cal;
sum_cal=0;
for(i=0;i<125;i=i+2)
{
temp=A*(*(ptr_buffer+i))+*(ptr_buffer+i+1);
sum_cal=sum_cal+temp;
}

if(lec_ecr==0)
{
sum=A*(*(ptr_buffer+126))+*(ptr_buffer+127);
if(sum_cal!=sum)
{
//MESSAGE D ERREUR de lecture a rajouter
}
else return(0);
}
else
{
*(ptr_buffer+126)=sum_cal/A;
*(ptr_buffer+127)=sum_cal-(*(ptr_buffer+126)*A);

}

return(0);
}

int verif_octets(unsigned char *ptr_buf)
{
int i;

/* On lit les octets compris entre 1 et 127 car le paramètre transmis
est le tableau "à_emettre" de 130 octets */

for(i=1;i<127;i++)
{
if(*(ptr_buf+i)!=*(ptr_buffer+i-1))
{
// MessageBox(hDlg,"Mauvaise transmission Perte de données","OK",MB_OK);
//mauvaise transmission perte de donnees
}
}
return(0);
}

unsigned char binary_code(int nombre,unsigned char *tampon)
{
int i;
unsigned char BCC;

BCC=*tampon;
for(i=0;i<nombre-1;i++)
{
BCC=BCC^*(tampon+i+1);
}
return(BCC);
}

int initialisation(void)
{
int fin=0,erreur;
unsigned char data_recu[2],init[3]="QQ";
unsigned long nBytesEmis,nBytesRecus;

do

{

erreur=emet(2,init,&nBytesEmis);

if(erreur==0) return 0;

erreur=acquiert(2,data_recu,&nBytesRecus);

if(erreur==0) return 0;

if(data_recu[1]!='Q')
{
printf("erreur d initialisation du BIS C-600");
// MessageBox(hDlg,"Erreur d'initialisation du BIS C-600","ERREUR",MB_OK);
return 0;
}
else fin=1;

}
while(fin==0);

return(1);
}

int acquiert(int nombre,unsigned char *buffer,unsigned long* nBytesRead)
{
int fin=0;

if(ReadCOM(buffer, nombre, nBytesRead))
{

printf("Reception OK");
// MessageBox(hDlg,"Acquisition réalisée","OK",MB_OK);
}
else
{
printf("probleme la donnee ne peut etre lue");
// MessageBox(hDlg,"La Donnée ne peut pas être émise","ERREUR",MB_OK);
return 0;
}
return(1);
}

int emet(int nombre,unsigned char *buffer,unsigned long* nBytesWritten)
{
int fin=0;

if(WriteCOM(buffer,nombre, nBytesWritten))
{
printf("ENVOI OK");
// MessageBox(hDlg,"Envoi realise","OK",MB_OK);
}
else
{
printf("probleme la donnee ne peut etre émise");
// MessageBox(hDlg,"La Donnée ne peut pas être émise","ERREUR",MB_OK);
return 0;
}
return(1);
}

ANCAT[font=Comic Sans MS]
Afficher la suite 

Votre réponse

1 réponse

Meilleure réponse
ymca2003 2070 Messages postés mardi 22 avril 2003Date d'inscription 3 juillet 2006 Dernière intervention - 18 août 2004 à 21:53
3
Merci
commandes possibles pour EscapeCommFunction() :

CLRDTR Clears the DTR (data-terminal-ready) signal.
CLRRTS Clears the RTS (request-to-send) signal.
SETDTR Sends the DTR (data-terminal-ready) signal.
SETRTS Sends the RTS (request-to-send) signal.
SETXOFF Causes transmission to act as if an XOFF character has been received.
SETXON Causes transmission to act as if an XON character has been received.
SETBREAK Suspends character transmission and places the transmission line in a break state until the ClearCommBreak function is called (or EscapeCommFunction is called with the CLRBREAK extended function code). The SETBREAK extended function code is identical to the SetCommBreak function. Note that this extended function does not flush data that has not been transmitted.
CLRBREAK Restores character transmission and places the transmission line in a nonbreak state. The CLRBREAK extended function code is identical to the ClearCommBreak function.

Merci ymca2003 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 78 internautes ce mois-ci

Commenter la réponse de ymca2003

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.