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]