Bonjour, j'ai un soucis plutot embetant. J'ai un programme de communication série, dont j'ai trouvé des codes sources sur ce site. Je l'ai modifié, et il me permet de communiquer avec une petite balance. Celle ci m'envoie une trame de donnée contenant l'information du poids qu elle a pesé.
Je découpe cette trame et je vais ecrire le poids recu dans un fichier texte. Donc mon programme fonctionne à merveille, sauf que quand je redémarre mon pc, et que je lance mon programme je n'arrive plus a communiquer avec ma balance comme si la trame ne passait pas ou mal. Il faut d'abord que je lance l hyperterminal pour que mon programme refonctionne normalement.
Alors il faut bien comprendre que c'est pas génial, si à chaque fois que mon pc redémarre je suis obligé de relancer l hyperterminal pour pouvoir me servir de mon programme.
Donc je ne sais, quesque fais de plus l'hyperterminal par rapport a mon programme? Est ce que l'hyperterminal débloque qqqchose, ou reset une mémoire . Je ne sais pas.
Je vous joins mon code.
Merci
// FICHIERS D'INCLUSION
//------------------------------------------------------------------------------
#include <windows.h>
#include <winbase.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <fstream>
#include <iostream>
using namespace std;//permet d'utiliser cin et cout avec iostream.(Remplace iostream.h sous C++ 6.0)
// CONSTANTES
//-------------------------------------------------------------------------------
// Définition du code d'erreurs
typedef enum
{
e_ErrCom_None, // Pas d'erreur
e_ErrCom_Creation, // Erreur lors de la création du flux
e_ErrCom_Utilise, // Le port com est déjà utilisé
e_ErrCom_Inexistant, // Le port com n'existe pas
e_ErrCom_Timeout, // Timeout lors d'une émission-réception
e_ErrCom_Emission, // Erreur lors de l'émission
e_ErrCom_Reception, // Erreur lors de la réception
e_ErrCom_Definition_Trame, // Erreur de définition de la trame
e_ErrCom_Nack, // Demande non prise en coompte #include ""
e_ErrCom_Checksum // Erreur de checksum
} e_ErrCom;
// Nom du port série
#define PORT1 "COM1"
#define PORT2 "COM2"
// Définition des vitesses de communication
#define V1200 1200
#define V2400 2400
#define V4800 4800
#define V9600 9600
// Définition du nombre de bits
#define BITS_7 7
#define BITS_8 8
// Définition du nombre de bits de stop
#define BIT_DE_STOP_1 1
#define BIT_DE_STOP_2 2
// Définition de la parité
#define PAS_DE_PARITE 'N'
#define PARITE_IMPAIRE 'O'
#define PARITE_PAIRE 'E'
// Codes de retour génériques
#define OK 1
#define KO 0
// Longueur max réservée pour une trame
#define LG_TRAME 100
// PROTOTYPES
//----------------------------------------------------------------------------
e_ErrCom OuvreCom(char *strPort,long BaudRate,int BitsSize,int Parity,int StopBits);
e_ErrCom EmissionCom(const void *lpBuf, unsigned int nCount);
e_ErrCom ReceptionCom(void *lpBuf, unsigned int nCountMax, unsigned int *pCountRead);
void FermeCom();
// VARIABLES GLOBALES
//-----------------------------------------------------------------------------
DCB g_DCB; // structure dcb du port
e_ErrCom g_ErrCom= e_ErrCom_None; // Variable des erreurs de com
HANDLE g_hCom = 0; // handle de la com
HWND hyper_term; // handle de la com
char *trameRecue [10];
char trame_essai[50];
//Nombre de caracteres maxi a lire
unsigned int NbMaxCar=100;
//pointeur sur le nombre de caractère recu
unsigned int NbCarRecus;
void main (void)
{
cout<<"Programme qui travaille avec le port COM1"<<endl<<endl;
int key=0,i=0, t=0;
char a;
bool trame_erreur=false;
ofstream fs; //Déclaration de la variable qui permet l'écriture dans un fichier
ifstream fs_config;
char chaine_fichier_config[] = "C:\\saisie_pesee\\config3.txt";
char chaine[100];
fs_config.open(chaine_fichier_config);
if(!fs_config.is_open())
{
cout << chaine_fichier_config << endl << "Le fichier de config n'a pas pu etre ouvert." << endl;
}
else
{
cout << "Fichier de config ouvert." << endl<<endl;
}
fs_config.getline(chaine, 40);
fs_config.close();
cout << chaine << endl;
//Test d'ouverture du fichier qui contient l'information du poids
fs.open(chaine);
if(!fs.is_open())
{
cout << "Le fichier n'a pas pu etre ouvert." << endl;
}
else
{
cout <<"Fichier ouvert, vous pouvez utiliser le systeme de pesee." << endl<<endl;
fs.close();
}
/* Nous sommes maintenant dans la boucle principale
qui permet de recevoir des événements */
do
{
i=0;
trame_erreur=false;
/*Configuration du port serie :
PORT2,V9600,BITS_8,PARITE_PAIRE,BIT_DE_STOP_1*/
g_ErrCom=OuvreCom(PORT1,V9600,BITS_8,PAS_DE_PARITE,BIT_DE_STOP_1);
//Réception
g_ErrCom=ReceptionCom(trame_essai,NbMaxCar,&NbCarRecus);
if(trame_essai[0]!='\0')//Arrivée d'une nouvelle trame. Traitement de celle ci si elle n'est pas nulle.
{
cout<<"Attention Reception et Ecriture..."<<endl;
cout<<"Trame Recue : ";
cout<<trame_essai;
if(trame_essai[19]!='g'){cout<<endl<<"La trame n'est pas correcte"<<endl<<endl;trame_erreur=true;}
if(trame_erreur==false)cout<<"Poids : ";
fs.open(chaine);
while(i<40)
{
a=trame_essai[i];
if(i>12 && i<18 && trame_essai[19]=='g')
{
if(!fs.is_open()) cout<<"mauvais fichier"<<endl;
else{
fs<<a;
cout<<a;
}
}
trame_essai[i]='\0';
i++;
}
if(trame_erreur==false)cout<<" kg"<<endl;
if(trame_erreur==false)cout<<"Fin Reception"<<endl<<endl;
fs.close();//Fermeture du fichier
}
FermeCom();//Fermeture du port de communication
} while( key!=1 );
}
//------------------------------------------------------------------------------
// FONCTION : OuvreCom
//------------------------------------------------------------------------------
// DESCRIPTION :
// Initialise et ouvre un port série
//
//------------------------------------------------------------------------------
// PARAMETRES :
// - strPort Nom du port "COM1", "COM2"
// - BaudRate Vitesse
// - BitsSize Taille de l'info
// - Parity Parité
// - StopBits Nombre de bits de stop
//
// RETOUR :Code d'erreur
//------------------------------------------------------------------------------
e_ErrCom OuvreCom(char *strPort,long BaudRate,int BitsSize,int Parity,int StopBits)
{
g_ErrCom = e_ErrCom_None;
// On ouvre le port série
g_hCom = CreateFile(strPort,GENERIC_READ | GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING,NULL);
if(g_hCom == INVALID_HANDLE_VALUE)
{
// Echec
g_ErrCom=e_ErrCom_Creation;
}
else
{
// On vide les buffers
PurgeComm(g_hCom,PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
// On paramètre le port série
g_DCB.DCBlength = sizeof(DCB);
//Configuration actuelle
GetCommState(g_hCom, &g_DCB);
//Modification du DCB
g_DCB.BaudRate=BaudRate;
g_DCB.ByteSize=BitsSize;
g_DCB.Parity=Parity;
g_DCB.StopBits=StopBits;
g_DCB.fDtrControl=DTR_CONTROL_DISABLE;
//Configuration de la liaison serie
SetCommState(g_hCom,&g_DCB);
}
return g_ErrCom;
}
//----------------------------------------------------------------------------
// FONCTION : EmissionCom
//----------------------------------------------------------------------------
// DESCRIPTION :
// Emission d'octets sur la liaison série
//
//----------------------------------------------------------------------------
// PARAMETRES :
// -lpBuf Pointeur sur les octets a emettre
// -nCount Nombre d'octet a emettre
//
//----------------------------------------------------------------------------
// RETOUR :Code d'erreur
//----------------------------------------------------------------------------
e_ErrCom EmissionCom(const void* lpBuf,unsigned int nCount)
{
DWORD NumBytes=0;
if(g_hCom!=NULL)
{
// On pari sur pas d'erreur
g_ErrCom=e_ErrCom_None;
//Emission du buffer
if(WriteFile(g_hCom,lpBuf,nCount,&NumBytes,NULL)==0)
{
g_ErrCom=e_ErrCom_Emission;
}
}
else
//Le port n'a pas été ouvert
g_ErrCom=e_ErrCom_Creation;
return g_ErrCom;
}
//---------------------------------------------------------------------------
// FONCTION : ReceptionCom
//---------------------------------------------------------------------------
// DESCRIPTION :
// Reception de caractères sur la liaison série
//
//---------------------------------------------------------------------------
// PARAMETRES :
// -lpBuf Pointeur sur le buffer de caractère a lire
// -nCountMax Nombre maxi de caractère a lire
// -pCountRead Pointeur sur le nombre de caractères lus
//---------------------------------------------------------------------------
// RETOUR :Code d'erreur
//---------------------------------------------------------------------------
e_ErrCom ReceptionCom(void *lpBuf,unsigned int nCountMax, unsigned int* pCountRead)
{
COMSTAT Stat;
DWORD Errors;
unsigned int nCarALire;
unsigned long NCarLus=0;
if(g_hCom!=NULL)
{
//on pari sur pas d'erreur
g_ErrCom=e_ErrCom_None;
//Pour éviter de gérer un time out; Laisse le temps de recevoir la trame.
Sleep(1000);
//Pour connaitre le nombre d'octets dans le buffer d'entrée
ClearCommError(g_hCom,&Errors,&Stat);
nCarALire=Stat.cbInQue;
//On effectue la lecture si il y a des caractères présents
if( (nCarALire>0)&&(nCarALire<=nCountMax) )
{
if(ReadFile(g_hCom,lpBuf,nCarALire,&NCarLus,NULL)==0)
{
g_ErrCom=e_ErrCom_Reception;
}
}
*pCountRead=NCarLus;
}
else
//Le port n a pas été ouvert
g_ErrCom=e_ErrCom_Creation;
//Compte rendu de l'exécution
return g_ErrCom;
}
//-----------------------------------------------------------------------
// FONCTION : FermeCom
//-----------------------------------------------------------------------
// DESCRIPTION :
// Ferme le port série préalablement ouvert avec OuvreCom
//
//-----------------------------------------------------------------------
// PARAMETRES :
// Néant
//-----------------------------------------------------------------------
// RETOUR :Néant
//-----------------------------------------------------------------------
void FermeCom()
{
if(g_hCom!=NULL)
{
CloseHandle(g_hCom);
}
}