CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2010 09 06 12:00:04

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

Périphériques

> FONCTION DE GESTION DU PORT SÉRIE (OUVERTURE,EMISSION,RECEPTION)

FONCTION DE GESTION DU PORT SÉRIE (OUVERTURE,EMISSION,RECEPTION)

Information sur la source

Note :

9,08 / 10

Catégorie :Périphériques Niveau :Débutant Date de création :24/07/2003 Date de mise à jour :24/07/2003 13:56:33 Vu :42 493

Auteur : gplog

Ecrire un message privé

Commentaire sur cette source (58)

Ajouter un commentaire et/ou une note

Description

Voila quelques fonctions pour gérer le port série écrites en C ansi et donc compatible avec tout les compilateurs .
J'ai extrait ces fonctions d'une source que j'ai fait en cour, je met donc aussi toute la partie header avec l'énum de gestion des erreurs, les constantes de configuration, et les variables globales qui sont utilisées dans les fonctions.

Source

// FICHIERS D'INCLUSION
//------------------------------------------------------------------------------
#include <windows.h>
#include <winbase.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
// 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
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
void main (void)
{
//Exemple de configuration du port serie :
g_ErrCom=OuvreCom(PORT1,V9600,BITS_8,PARITE_PAIRE,BIT_DE_STOP_1);
//Exemple d'emission
g_ErrCom=EmissionCom("UneTame",sizeof("UneTame"));
}
//------------------------------------------------------------------------------
// 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
Sleep(500);
//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);
}
}

// FICHIERS D'INCLUSION
//------------------------------------------------------------------------------
#include <windows.h>
#include <winbase.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>

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


void main (void)
{
	//Exemple de configuration du port serie :
	g_ErrCom=OuvreCom(PORT1,V9600,BITS_8,PARITE_PAIRE,BIT_DE_STOP_1);
	//Exemple d'emission
	g_ErrCom=EmissionCom("UneTame",sizeof("UneTame"));

}


//------------------------------------------------------------------------------
// 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
		Sleep(500);

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

Sources de la même categorie

[DEV-C++] GESTION DU PORT PARALLÈLE par victorcoasne

FAIRE GLISSER LA SOURIS par shorzy

COMMUNICATION RS232 VIA PORT COM par MadMax1024

EXTINCTION ET REDEMARRAGE DE VOTRE MONITEUR À UNE HEURE PRÉC... par Yost

ÉTEINDRE ECRAN SOUS WINDOWS par kiki67100

Toutes les sources de la catégorie Périphériques

Commentaires et avis

Commentaire de eldered le 24/07/2003 20:18:13

Salut, tu es en quelle sections ?

Commentaire de gplog le 25/07/2003 08:54:27

Je suis en formation post bts en informatique industrielle et automatisation.

Commentaire de eldered le 25/07/2003 13:09:17

okok, ton prog je n'arrive pas le lancer sous dev c+, je le compile et le lance, ms il s'arréte de suite ... tu compiles avec koi ? tu pe mettre un exe plz ? !

++

Commentaire de gplog le 25/07/2003 14:17:07

C'est normal si y s'arrete tout de suite. Y'as presque rien dans le main(un exemple de main). C'est juste un outil pour utiliser le port série, à toi de l'utiliser selon ton application.
Ici le main envoie seulement la chaine "UneTrame" vers le port série.-->donc c'est tres court.

Commentaire de matt48 le 27/08/2003 18:39:08

Bonjour,
Je trouve ce code super.
Ca fonctionne très bien sous mon windows 2000, mais ça ne marche pas du tout sous win98. Comme si rien ne passait sur le port. Tu aurais une idée. J'ai testé mon executable sur 3 PCs avec win98.
Merci, d'avance,
Matthieu

Commentaire de gplog le 28/08/2003 09:41:36

Arff, alors là, matt je peut pas faire grand chose pour toi, j'ai toujours dévelloppé sur Win2000.
Et donc, j'ai jamais eu de problèmes.
Pour voir si des infos passent sur ton port série, tu peut utiliser un bouchon (tu relie les broches numéro 2 et 3 de ton port série). Avec le bouchon, tout ce que tu envoi revient vers ton PC donc, tu peut vérifier ce que tu envoi en faisant un réception sur ton port.

Commentaire de matt48 le 28/08/2003 12:41:48

Ok, merci.
C'est ce que je voulais tester.
Mais je vois que d'autres ouvrent le port ce cette façon :
CreateFile("COM1:",GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL)
Alors que toi, tu utilises : (FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING) à la place de FILE_ATTRIBUTE_NORMAL.
Quelles sont les différences ?
tu connais la fonction SetupComm, si oui, comment l'utiliser, stp.
Merci.
A+
Mon E-mail : matt48@wanadoo.fr

Commentaire de loic81 le 12/09/2003 17:43:31

Salut,
chouette ce driver pour pour com. Pour info, il marche aussi sous win95...
T'aurrais pas une ligne de code avec un exemple de réception Stp ?
merci d'avance...

remarque amicale à Matt48 : le forum, c'est fais pour partager des connaissances, donc l'utilisations d'email, c'est pas super pour ceux qui aurons besoin des mêmes infos que toi...

Commentaire de loic81 le 12/09/2003 17:44:36

Commentaire de gplog le 16/09/2003 09:27:40

Salut loic,
voila pour toi un exemple de réception :
// Déclaration des Variables :
// Pointeur sur les caractères reçus
void * TrameReçue;
// Nombre maxi de caractère a lire (ici 100)
unsigned int NbMaxCar=100;
// Pointeur sur le nombre de caractère recus
unsigned int* NbCarReçus;

//Exemple de réception
g_ErrCom=ReceptionCom(TrameReçue,NbMaxCar,NbCarReçus);

Je sais pas trop si ça fonctionne parceque j'ai rien pour tester.

Commentaire de loic81 le 17/09/2003 15:47:48

Merci, ça marche impec.

Commentaire de shkyo le 23/09/2003 17:51:06

Salut, une simple petite question, tu mets que c'est en C ANSI, mais je vois dans les includes windows, winbase et conio, donc cela peut-il marcher sous Linux ???

Commentaire de loic81 le 24/09/2003 09:54:48

à mon avis, avec les readfile() et writefile(), tu ne pourras pas l'utiliser sous linux, car ce sont des fonctions de windows API...

Commentaire de Looping.net le 19/11/2003 12:17:38

Hello,

vraiment chouette ce morceau de code, après 3 jours de recherche sur le net, c'est le plus simple et un des rares que j'ai réussit à compiler !

L'ouverture du port et l'écriture se passent sans problèmes, par contre pour la lecture j'ai un petit soucis : il m'indique l'erreur suivante :
"L'instruction à "0x0040160a" emploie l'adresse mémoire "0x78001e6e". La mémoire ne peut pas être "written"."

J'utilise Windows 2000 SP2 et comme compilateur, j'utilise Dev C++ 4.

En placant quelques printf dans la fonction "ReceptionCom",
Je vois qu'il passe la fonction ClearCommError, et que la variable nCarALire n'est pas nulle. Mais il plante ensuite, et m'affiche l'erreur.

Est-ce que quelqu'un a eut ce problème et sait comment le résoudre ?

Commentaire de ender_ le 08/12/2003 18:14:08

j'ai le même problème que Looping.net. Si vous avez une solution, prière de l'expliquer sur le forum..

Commentaire de ender_ le 09/12/2003 09:25:20

je pense que le problème provient du fait que le ponteur de fichier "dépasse" le EOF courant lors de la lecture du fichier...
Seulement comment remédier ce problème..qqu'un a une suggestion?

Commentaire de ender_ le 09/12/2003 10:46:36

En fait l'erreur est ERROR_NOACCESS
qq'un peut m'aider pour remedier ce problème?

Commentaire de loic81 le 10/12/2003 10:04:57

Je n'ai pas la réponse, mais je vous indique que ça ne fonctionne pas sous windows 95 (et oui, ça existe encore!!!) compilé avec Borland 5.02.
par contrre, ça fonctionne sous windows NT4
Bon courage

Commentaire de ender_ le 11/12/2003 09:44:01

En ce qui me concenre , je développe sous Windows 2000 Pro,
sous l'environnement Visual C++ 7 de la plate forme .NET 2003..le programme marche bien, il bug seulement lors de la lecture (ReadFile(...) )
j'utilise une boucle locale : seulement les pins 2 et 3 du port série sont reliées...l'erreur provient de là?
merci d'avance.

Commentaire de ymca2003 le 14/12/2003 16:34:28

Pour réception : pb dans la solution de gplog :

void * TrameReçue;
unsigned int NbMaxCar=100;
unsigned int* NbCarReçus;
g_ErrCom=ReceptionCom(TrameReçue,NbMaxCar,NbCarReçus);

les données recus vont être écrite là où pointe TrameReçue c'est à dire à peu près n'importe où en mémoire (pointeur non initialisé)
=> à remplacer par :
unsigned char TrameReçue[100];
unsigned int NbMaxCar=100;
unsigned int* NbCarReçus;
g_ErrCom=ReceptionCom(TrameReçue,NbMaxCar,NbCarReçus);

Commentaire de vavincavent le 21/12/2003 23:59:00

Bonjour,
je suis totalement débutant en programmation C.
Votre code m'intéresse pour extraire des données d'un ordinateur de plongée.
j'ai installé dev-c++ et je souhaiterai écrire la lecture du port com1 dans un fichier. Comment faire?
Il faudrait que le programme se mette en attente d'un flux de données puis qu'il enregistre les données reçues.
merci de votre aide.
Vincent

Commentaire de pierrejarod le 12/01/2004 09:47:26

Bonjour,
Je programme sur Borland 5.0 et j'ai un problème avec ce programme (mais pas le même que tout le monde semble avoir).
Le voici : "L'exécutable a provoqué une classe d'exception EAccessViolation avec le message 'Violation d'accès à l'adresse 0040130B. Ecriture de l'adresse 00000000' ".
Est-ce que quelqu'un aurait rencontré la même erreur ou/et aurait une idée?
Merci d'avance

Commentaire de pierrejarod le 12/01/2004 10:01:54

Rebonjour,
Petit rajout :
Le programme reste apparemment bloqué sur : " *pCountRead=NCarLus; ".

Merci

Commentaire de ymca2003 le 12/01/2004 12:48:10

dans la correction que j'avaid donné, il y a une erreur sur le dernier paramètre
unsigned char TrameReçue[100];
unsigned int NbMaxCar=100;
unsigned int NbCarReçus;
g_ErrCom=ReceptionCom(TrameReçue,NbMaxCar,&NbCarReçus);

Commentaire de lioyoyo le 20/01/2004 15:08:13

Bonjour,
Ce code marche bien mais j'ai un souci pour declencher l'envoi des données de ma carte d'acquisition (srs245). J'ai lu que l'envoi se déclenchait quand le signal DTR (terminal de donnée pret) sur la pin 20 est validé. La fonction de réception prend-t-elle en compte ce genre de considération? Dans le cas contraire, comment forcer la validation de la pin 20?

Merci

Commentaire de Looping.net le 23/01/2004 13:19:18

Merci à ymca2003 pour sa petite correction, ca marche pile poil :) En tout cas sous 2000.
Je n'ai toujours pas réussit à faire fonctionner ce code sous Windows 98.

J'ai par contre trouvé entre temps ce site :
http://www.wince.org.uk/vc/intermediate/serialrw.htm
les deux fichiers zip contiennent les sources qui fonctionnent après une ou deux petites modif (faut rajouter une ligne blanche à la fin de chaque fichier .h et .cpp et il faut rajouter #include <stdio.h> )

Et ce code fonctionne sous Windows 98. L'inconvénient c'est qu'il travaille bit par bit au lieu de travailler par chaîne de caractère comme le programme de gplog.
Je vais travailler dessus pour essayer de comprendre, et dès que j'ai plus d'infos, je reposte un message.
Si quelqu'un trouve la solution avant moi ce serait cool de poster

Looping

Commentaire de jackyjacky le 11/02/2004 11:38:30

Salut
j'aimerais savoir si on pourrais adapter le code pour transmettre un fichier complet par exemple (de taille résonnable)
Merci

Commentaire de virtuA le 07/04/2004 18:43:58

Super ton code!!
je te remercis, car ca fait un petit moment que j'en cherché un, qui
tienne la route en C, car je boss en VB, mais j'essais de passé en C,
ton code va bcq m'aider merci encore ;)

Commentaire de virtuA le 07/04/2004 20:11:08

Comme je debute , je voudrais te demander si tu peux me dire a quoi corresponde tes Headers STP ;

#include <windows.h> //compatibilité entre windows
#include <winbase.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>

merci ca m'aiderai bcp :)

Commentaire de olischlo le 02/07/2004 14:38:07

Il y a juste un petit souci avec ce code.

Lorsque je le lance l'appli, cela ne fonctionne que si prélablement une autre appli (ex: Hyperterminal) a déjà utilisé le PortCom. Sinon tous semble bien se passer, mais dans les fait aucun carractère n'est lu ou envoyé via le port série...

Ceci a été testé sur plusieurs PC sous Win2000.

J'ai pas vraiment réussi à trouver le pourquoi...

Commentaire de sbommer le 06/10/2004 09:53:23

Je rencontre exactement le meme probleme que Olischlo,
Si quelqu 'un trouve la source de ce problème, je suis vraiment interessé (testé sur XP fam et XP pro)

Merci

Commentaire de sbommer le 06/10/2004 11:56:29

pour le petit soucis avec le code,(olischlo)
il s'agit visiblement d'un probleme sur les valeurs
de Parity et StopBits.

en forcant ces valeur dans le "OuvreCom"
g_DCB.Parity=NOPARITY; //=Parity;
g_DCB.StopBits=ONESTOPBIT; // =StopBits;
le probleme se resoud.C'est donc juste un petit soucis sur les formats de ces 2 variables.

Ce code est super, merci à gplog

Commentaire de olischlo le 06/10/2004 17:57:36

sbommer > C'est bien possible que ce soit cela... j'avais corrigé le problème, mais je ne me souvient plus vraiment comment...

Commentaire de blaise_laporte le 02/03/2005 16:21:30

Bonjour
Dabord, merci beaucoup pour cette source qui m'a évité de longues heures laborieuse (je debute en programation).
Le probleme:
Lorsque je fais un boucle contenant l'ouverture de la com, l'écriture et la fermeture (pour envoyer plusieur fois d'affillé le même message) il me dit qu'il n'a pas reussi à créer le flux des la deuxieme ocurence de la boucle, alors que la premiere fois, ça fonctionne impec. Je ne sais pas à quoi c'est dus.
Merci.

Commentaire de tagadaboum le 25/03/2005 10:31:50

Merci beaucoup pour le source il m'a fait gagné du temps par contre il m'en a fait perdre aussi ....
Mais j'ai finit par trouver le problem :
Attention :
Quand tu fais SetCommState(g_hCom,&g_DCB); tu testes pas le retour et il se trouve que ça plante.
Pourquoi ?
Par ce que les constante que tu définis ne sont pas les bonnes pour :
/#define BIT_DE_STOP_1   1
#define BIT_DE_STOP_2   2
#define PAS_DE_PARITE   'N'
#define PARITE_IMPAIRE  'O'
#define PARITE_PAIRE    'E'

Il faut utiliser ces constante qui sont déjà définis dans je ne sais quel .h :
NOPARITY EVENPARITY  ODDPARITY
ONESTOPBIT  ONE5STOPBITS   TWOSTOPBITS
et là ça marche !

Commentaire de angsthase le 05/04/2005 16:56:59

Merci pour ta source ( ca fais toujours plaisir) !!!
Mais chez moi j'ai voulu tester( le truc avec les broches ) et quand il veut faire la reception, Windows 2000 SP4 me mùets un message d'erreur et ferme l'appli ?!?!?!?!?!?!?!?!?
J'utilise dev-c++!
mon main donne ceci à present :
/*************************************************************
*                                   MAIN
*************************************************************/
main()
{
    unsigned char TrameRecue[100];
    unsigned int  NbMaxCar=100;
    unsigned int *NbCarRecus;

    //Exemple de configuration du port serie :
    g_ErrCom=OuvreCom(PORT3,V9600,BITS_8,PARITE_PAIRE,BIT_DE_STOP_1);

    //Exemple d'emission
    g_ErrCom=EmissionCom("UneTame",sizeof("UneTame"));
     system("PAUSE");
    //Exemple reception.
   g_ErrCom=ReceptionCom(TrameRecue,NbMaxCar,NbCarRecus);
    system("PAUSE");
}

Commentaire de angsthase le 05/04/2005 16:59:21

et avec cette ligne :
g_ErrCom=ReceptionCom(TrameRecue,NbMaxCar,&NbCarRecus);

ca ne marche pas!

Commentaire de ymca2003 le 05/04/2005 17:00:22

Et ces 2 lignes :

unsigned int NbCarRecus;
g_ErrCom=ReceptionCom(TrameRecue,NbMaxCar,&NbCarRecus);

Commentaire de perig le 13/04/2005 16:37:27

salut et merci ca marche

Mais je cherche a envoyer une trame 0xAA soit '10101010' et je ne recois que 0x0A soit '00101010' (je perd le bit de poid fort de toutes mes trames) on dirait qu'il n'envois que 7 bits pourtant j'ai bien mis 8bits dans la config du port.
sais tu d'ou ca peut venir

merci

Commentaire de perig le 14/04/2005 09:52:58

finalement ca marche... ca ne marche que les jours pair lol

Commentaire de Revan777 le 18/04/2005 10:55:16

Salut, je suis en BTS IRIS en alternance et je dois développer justement un prog en C pour la reception de donnees sur le port COM (lecture de Code-barr à partir d'une douchette automatique).
J'ai trouvé un code qui ressemble à celui-ci et que j'ai modifié pour pouvoir stocker mes Code-barr dans un fichier pour ensuite les insérer dans une BDD sur l'intranet de l'entreprise. Mais le problème que j'ai, c'est que mon code n'est pas compatible Windows98 (sur XP, nickel). Alors voila suis en stress pour pouvoir fournir le prog à temps. SVP HELP ME.
Je laisse mon code complet avec le fichier de config (certes modeste, fo pas exagerer j'suis qu'en 1ere annee !) sur le site que je développe actuellement:
http://btsiris.network-hosting.com/COM/COM.zip

Je souhaitais savoir si le code de gplog était compatible Win98 et comment le modifier pour qu'il fasse exactement comme celui que vous trouverez sur mon site.
MERCI !

Commentaire de Revan777 le 18/04/2005 11:24:05

J'ai pensé aussi à une histoire de librairies supplémentaires à ajouter car l'errreur que j'obtiens en executant le programme sous Win98 c'est à la reception:
TestCOM a causé une défaillance de page dans le module MSVCRT.DLL à 0167:7800ffd0......
(Ce fichier dll comprend apparemment une bibliothèque de fonctions pour les applications Visual.)

Commentaire de ymca2003 le 18/04/2005 11:31:48

Le code dont tu parles et dont tu fourni le lien est le mieux apparemment.

Celui-ci (en tout cas la version originale de messources sur ce site) fonctionne sur n'importe quelle version de Windows 32 bits (Win9x, ME, NT, 2k, XP).

Ton pb doit venir du fait que tu compile en Debug et non en Release.

Commentaire de ymca2003 le 18/04/2005 11:33:33

Erreur de frappe qui peux préter à confusion dans ma première phrase du post précédent (mien au lieu de mieux):

"Le code dont tu parles et dont tu fourni le lien est le mien apparemment."

Commentaire de NiChaN le 20/04/2005 18:05:58

Moi je ne comprend pas pourquoi personne ne pense a faire des class, c beaucoup plus simple d'utilisation en finale !!
Une class GesComSerie pas exemple, et grace au methode n'importe qui peut l'utiliser a ca convenance dans son main ou bien meme en MFC GRAPHIQUE !
Voila !!

Pensez à cree des class !!

Commentaire de momo_le_dingue le 17/05/2005 19:30:02

voila je sis debutant en programmation. je suis en bts info et pour mon stage je dois faire un petit programme pour faire tourner des petits mooteurs et je crois qui se branchent en port série. je souhaiterai de l'aide. merçi d'avance

Commentaire de proj le 27/03/2006 16:38:13

voilà j'ai testé le prog de GPLOG et mon compilateur (Borland C++) ne reconnait pas la fonction OuvreCom().
Que doi-je faire?
Je travaille sous windows 2000

Merci

Commentaire de DMK04 le 11/04/2006 14:10:33

salut,
depuis ce matin je cherche des sources pour voir un peu comment utiliser le port série, et ben ça fait plaisir qu'il y ait des gens qui ne programment pas comme des "porcs". Enfin un code qu'on comprend quand on le regarde ! gg ;)
Pas encore testé, mais il a le mérite d'être clair :)
a+

Commentaire de seedtrunks le 12/04/2006 15:21:57

Bonjour,
Je suis en stage et débutant en programmation et je cherche un programme qui fonctionne avec dev C++ sous XP qui permettrai d'activer les ports série.Si quelqu'un a ce programme je suis preneur.
Merci d'avance

Commentaire de Geaby le 17/05/2006 12:44:45

Bonjour,
je suis en stage et debutant en programmation. Dans le cadre de mon projet je dois controler chaque broche de mon port serie pour asservir des servo-moteurs. Je souhaiterai donc savoir comment ce programme utilise physiquement les broches des ports. Ou si quelqu'un connait un programme controllant individuellement chaque broche du port, je suis preneur :)
Merci
A plus

Commentaire de Famidoo le 07/06/2006 10:26:41

et pour l'USB, c'est similaire ?

Commentaire de rexdan le 26/09/2006 12:16:42

salut à tous

Je suis nouveau sur CPPFRANCE, et aussi dans la merde.... n'étant pas non plus un Dieu en C, je dois réaliser un code en C (SIMPLE!!!) sur VC++, et le programme de gplog ne fonctionne pas géniale (sans aucun doute du à mon ignorance du C); surtout au niveau de la réception des données. En fait je dois envoyer des données en Hexa du genre 23 01 24 0D... et ensuite recevoir des données d'une carte controleur.
Voici mon main, où je tente de débugger/comprendre un peu... mais je patauge.... Y aurait il une bonne ame....

Merci

Rex

void main (void)
{
char buffer[256];
unsigned int  NbMaxCar=100;
        unsigned int *NbCarRecus;

printf("enter the command: \n");
scanf("%s",&buffer);
    //Exemple de configuration du port serie :
    g_ErrCom=OuvreCom(PORT1,V19200,BITS_8,PAS_DE_PARITE,BIT_DE_STOP_1);

    //Exemple d'emission
    g_ErrCom=EmissionCom(buffer,sizeof(buffer) );
    printf("the buffer sent is: %s \n",buffer);

    // reception
    g_ErrCom=ReceptionCom(buffer,sizeof(buffer),&NbCarRecus);

}

Commentaire de Pilloutche le 07/04/2007 17:09:38

Salut a tous!
Vraiment géniale cette source!
avec ces deux lignes dans le programme 'test' cité plus haut, ca fonctionne parfaitement:

unsigned int NbCarRecus;
g_ErrCom=ReceptionCom(TrameRecue,NbMaxCar,&NbCarRecus);

Merci beaucoup ;-)

Commentaire de DarkIndra le 15/06/2007 09:23:30

Bonjour à tous, je suis en bts electronique, a la suite d'un dut informatique, et je suis en stage, je dois faire une interface lecteur de badge/base de données access. voila pour les "présentations" ^^
pour l'interface c'est fait, je test ce que je reçois avec le programme ci dessus (legerement modifier pour ne pas emettre par exemple) et donc j'envoi 2 octets (par l'intermédiaire d'un pic, et d'un max232 pour l'adaptation en tension) sur mon port série, seulement voila, par exemple je veux lui envoyer 1111.1111 1111.1111 (le point pour séparer pour la visibilité ;)
et lui il me reçoit 111.1111 0111.1111
donc pour finir, pourquoi n'accepte t'il que 7 bits et non les 8? (en effet le zéro devant la premiere série étant non significatif, il ne l'affiche pas ), j'ai beau chercher, cela vient de la fonction readfile et pourtant elle est paramétrée pour accepter 8bits.
Sinon pour les petites info, j'utilise dev-C++
Merci de votre attention et éventuellement de votre aide :)

Commentaire de Grandnord le 30/10/2007 23:32:07

Bonjour à tous,
Je désire faire fonctionner une boite d'interrupteur sous Linux. Pour cela je dois envoyer la chaine de caractères "N1" + le caractère ENTRER par le port série 1.

Est-ce que quelqun a une idée comment s'y prendre?

J'ai essayé:
g_ErrCom=EmissionCom("N1\0",sizeof("N1\0")); ????
Mais ca ne fonctionne pas... :C

Merci.

Commentaire de quentennis le 18/04/2008 09:27:24

Salut à tous

Ce code est vraiment génial, bien commenté et facile à comprendre, c'est vraiment un plaisir !!!
J'ai eu quelques petites difficultés à corriger les différentes erreurs (minimes !!), mais maintenant, ça marche impécable ! Le problème de la réception des données qui n'intervient que lorsque l'on a déjà ouvert une autre application via le port série vient en effet des variables que tu définis au départ :

BIT_DE_STOP_1 1
BITS_DE_STOP_2 2
PAS_DE_PARITE
PARITE_PAIRE
PARITE_IMPAIRE

Il faut supprimer ces variables que tu définis, et lorsque tu appelles ta fonction pour ouvrir le port série, il faut les remplacer par :

ONESTOPBIT
TWOSTOPBITS
NOPARITY
EVENPARITY
ODDPARITY

Voilà, j'espère que ça aidera ! Et encore merci à pour cette aide précieuse !

Commentaire de ramiaramila1 le 13/05/2008 09:29:01

est ce que vous pouvez me donner des documents sur la communication entre pc et automate (protocole, programme, ...), svp j'en ait besoin pour realiser un projet pour ma soutenance de mémoire.

Commentaire de zeom le 05/04/2010 14:19:01

salut est c que j'ai peut utilisé cette programme pour faire une communication entre visuel studio 2008 et un automate Omron

Ajouter un commentaire

Nos sponsors

Derniers Blogs

UTILISATION DE LA RéPLICATION SQL DANS LE CODE .NET D'UNE APPLICATION MOBILE - IMPLéMENTATION & CONSEILS : PARTIE 1/3 (CLASSE SQLCEREPLICATION & PREMIèRE SYNCHRO) par Pi-R

QUELQUES TRUCS INTéRESSANTS (05/09/2010) par coq

ENUMERABLECOLLECTION par Matthieu MEZIL

[HS] CHROME 6 + MOI = COUP DE GUEULE ! par JeremyJeanson

[WP7] UTILISER UN WRAPPANEL DANS UNE APPLICATION WINDOWS PHONE 7 par Audrey

Forum

RE : UTILISER QT SOUS ECLIPSE AVEC QT ECLIPSE INTEGRATION (LINUX) par Chatbour

RE : LISTE ET TABLEAU par nhervagault

LISTE ET TABLEAU par dida87

UTILISER QT SOUS ECLIPSE AVEC QT ECLIPSE INTEGRATION (LINUX) par Chatbour

OPENGL, DéFORMATION DES OBJETS par mohdaef

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Recherche consultant NET C Sharp
Budget : 12 000€
Integration parametrage formation Question writer 4 Hot potatoes
Budget : 300€
URGENT Creation site vitrine Joomla Laboratoire protheses dentaires
Budget : 600€

Logiciels

WebLogAndPass (1.0.0)
WEBLOGANDPASS (1.0.0)

WebLogAndPass est un logiciel permettant de mémoriser vos sites préférés et pour chacun d'entre-e...

Cliquez pour télécharger WebLogAndPass
uTorrent (2.0.4)
UTORRENT (2.0.4)

C'est un client BitTorrent très puissant et très performant. Comme son nom l'indique, uTorrent (m...

Cliquez pour télécharger uTorrent
Bureau de Gestion - ERP Devis Facturation (2.02)
BUREAU DE GESTION - ERP DEVIS FACTURATION (2.02)

- Version gratuite du 10/06/2010 Le Bureau de Gestion est un logiciel dédié à la gestion de l'en...

Cliquez pour télécharger Bureau de Gestion - ERP Devis Facturation
4Videosoft Transfert iPod Mac (3.2.08)
4VIDEOSOFT TRANSFERT IPOD MAC (3.2.08)

4Videosoft Transfert iPod-Mac caractérise principalement à transférer les fichiers iPod vers Mac....

Cliquez pour télécharger 4Videosoft Transfert iPod Mac
4Videosoft HD Convertisseur (3.3.08)
4VIDEOSOFT HD CONVERTISSEUR (3.3.08)

Etant le meilleur HD Vidéo Convertisseur, 4Videosoft HD Convertisseur, vous pouvez regarder la vi...

Cliquez pour télécharger 4Videosoft HD Convertisseur