IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

listen port parallele


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Profil pro
    Inscrit en
    Novembre 2004
    Messages
    26
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Novembre 2004
    Messages : 26
    Par défaut listen port parallele
    Bonjour,

    J'ai un bouton d'arret d'urgence connecte a un port parallele, mon but est que lorsque j'active le bouton, on envoi un bit(1 ou 0) via le port parallele, a un programme qui est toujours actif sur le PC.
    Avez-vous deja un bout de programme ou un example d'application de ce type? En fait, un programme qui tourne tout le temps sur la machine (windows)?

    Meric d'avance,
    MA.

  2. #2
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par mike21 Voir le message
    J'ai un bouton d'arret d'urgence connecte a un port parallele, mon but est que lorsque j'active le bouton, on envoi un bit(1 ou 0) via le port parallele, a un programme qui est toujours actif sur le PC.
    Avez-vous deja un bout de programme ou un example d'application de ce type? En fait, un programme qui tourne tout le temps sur la machine (windows)?
    Pourquoi un bout de programme ? Tu ne sais pas le faire toi même ? Tu as réfléchi au problème ? Tu t'es documenté sur le port // ? Tu sais comment accéder au port // Quel broche utiliser en entrée ?

    Visiblement, on doit tout faire à ta place, ben non, pas d'accord. Montre que tu as fait quelques études préalables, et on pourra t'aider avec ton code C si il ne fonctionne pas...

  3. #3
    Membre éprouvé Avatar de BainE
    Inscrit en
    Mai 2004
    Messages
    1 327
    Détails du profil
    Informations forums :
    Inscription : Mai 2004
    Messages : 1 327
    Par défaut
    Et pour Emmanuel HipHipHip

  4. #4
    Membre averti
    Profil pro
    Inscrit en
    Novembre 2004
    Messages
    26
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Novembre 2004
    Messages : 26
    Par défaut
    bonjour,

    Je vous fait part de mon programme ci dessous!
    Il fonctionne parfaitement, mais je n'arrrive pas a incerer mon bouton a l'interiur (j'arrive seulement a gerer mes port).
    En fait, des qu'on initialise le port com le DTR (data terminal ready) passe a -12V (logique 1). je n'arrive pas a detecter le signal sur DCD en appuyant sur le bouton

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
     
    // 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)
    {
    DWORD Errors;
    COMSTAT Stat;
    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;
    }
     
     
     
    //-----------reception des donnees---------------
    // Déclaration des Variables :
    // Pointeur sur les caractères reçus
    void * TrameReçue;
    // Nombre maxi de caractère a lire (ici 100)
    unsigned char TrameReçue[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);
     
     
     
     
    //-----------------------------------------------------------------------
    // 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);
    	}
    }

    merci de votre aide,
    Mike.

  5. #5
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par mike21 Voir le message
    Je vous fait part de mon programme ci dessous!
    Il fonctionne parfaitement,
    Prouve le...
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
     
    Project   : Forums
    Compiler  : GNU GCC Compiler (called directly)
    Directory : C:\dev\forums\
    --------------------------------------------------------------------------------
    Switching to target: default
    Compiling: main.c
    main.c:61: warning: function declaration isn't a prototype
    main.c:71: warning: return type of 'main' is not `int'
    main.c: In function `main':
    main.c:73: warning: passing arg 1 of `OuvreCom' discards qualifiers from pointer target type
    main.c: At top level:
    main.c:226: error: stray '\231' in program
    main.c:226: error: syntax error before "ue"
    main.c:226: warning: type defaults to `int' in declaration of `ue'
    main.c:226: warning: data definition has no type or storage class
    main.c:228: error: stray '\231' in program
    main.c:228: error: syntax error before "ue"
    main.c:228: warning: type defaults to `int' in declaration of `ue'
    main.c:228: error: conflicting types for 'ue'
    main.c:226: error: previous declaration of 'ue' was here
    main.c:228: warning: data definition has no type or storage class
    main.c:231: error: stray '\231' in program
    main.c:231: error: syntax error before "us"
    main.c:231: warning: type defaults to `int' in declaration of `us'
    main.c:231: warning: data definition has no type or storage class
    main.c:234: warning: type defaults to `int' in declaration of `g_ErrCom'
    main.c:234: error: conflicting types for 'g_ErrCom'
    main.c:66: error: previous definition of 'g_ErrCom' was here
    main.c:234: error: stray '\231' in program
    main.c:234: error: `TrameRe' undeclared here (not in a function)
    main.c:234: error: syntax error before "ue"
    main.c:234: error: stray '\231' in program
    main.c:252: warning: function declaration isn't a prototype
    main.c:257:2: warning: no newline at end of file
    Process terminated with status 1 (0 minutes, 2 seconds)
    14 errors, 12 warnings
    Ceci compile (je n'ai pas de port série sur ma machine, je ne peux pas vérifier le fonctionnement)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
     
    // FICHIERS D'INCLUSION
    //------------------------------------------------------------------------------
    #include <windows.h>
    #include <stdio.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
     
    // 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
     
    //------------------------------------------------------------------------------
    // 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 const *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)
    {
       DWORD Errors;
       COMSTAT Stat;
       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 (void)
    {
       if (g_hCom != NULL)
       {
          CloseHandle (g_hCom);
       }
    }
     
    int 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"));
       return 0;
    }
    Ta demande originelle concernait le port // Tu as abandonné ?

    OK. Donc, tu voudrais détecter un changement d'état sur le port série (circuit CD ou DCD ou 109). C'est certainement possible en récupérant le message de Windows correspondant, ou en testant régulièrement l'état du circuit.

    Mais pour ça, il n'y a pas besoin des fonctions d'émission et de réception de données. C'est bien de pomper du code ailleurs, mais si tu ne sais pas à quoi il sert, ni comment il fonctionne, ça ne sert pas à grand chose d'utile...

    Pour les messages, je ne sais pas faire (programmation Windows, il y a un forum pour ça). Pour lire l'état, il doit y avoir une fonction (GetCommModemStatus Function(), bit MS_RLSD_ON je suppose). MSDN est ton amie...

  6. #6
    Membre averti
    Profil pro
    Inscrit en
    Novembre 2004
    Messages
    26
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Novembre 2004
    Messages : 26
    Par défaut
    oui, j'ai abandonne le port parallele car il tend a disparaitre...
    par consequent, j'avance petit a petit en parallele les 2 solutions (windows et prog C).
    J'ai cree un programme d'ouverture de port, mais en faite c'est apres que je suis bloquer je ne sais pas trop comment gerer (est-ce que c'est le brochage qu'il faut modifier)?

Discussions similaires

  1. fonction "inb" sous linux; port parallele
    Par be_net dans le forum Autres éditeurs
    Réponses: 1
    Dernier message: 09/06/2004, 11h39
  2. [VB6]Commander plusieurs ports parallèle
    Par fab+ dans le forum VB 6 et antérieur
    Réponses: 5
    Dernier message: 24/03/2004, 14h56
  3. precision sur le pilotage du port parallele
    Par fransouik dans le forum C++Builder
    Réponses: 18
    Dernier message: 26/02/2004, 13h28
  4. Utiliser le port parallele pour simuler un digicode
    Par nonoRedDevils dans le forum Assembleur
    Réponses: 8
    Dernier message: 30/12/2003, 13h23
  5. Port parallele
    Par Phoneus dans le forum C
    Réponses: 2
    Dernier message: 05/05/2002, 23h19

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo