Discussion :

[kurul1]

Est-ce que quelqu'un aurais une solution pour piloter le port parallèle, autre que DlPortIO qui chez moi ne fonctionne plus avec BDS 2006

Merci d'avance

[blondelle]

Salut kurul1
Peut etre en utilisant quelque chose comme ceci, je ne suis pas sur du code, je n'ai pas la possibiite de l'essayer

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
 
void __fastcall TForm1::Button1Click(TObject *Sender)
{
DCB dcb;
HANDLE hComm;
BYTE bSign = 0xFF;
DWORD dwBytesRecive ;
hComm = CreateFile( "LPT1", FILE_READ_DATA | FILE_WRITE_DATA, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(hComm == INVALID_HANDLE_VALUE)
{
MessageBox(Form1->Handle,"Can't open file","Error",MB_OK+MB_ICONERROR);
}
if((GetCommState(hComm, &dcb))==0)
{
MessageBox(Form1->Handle,"GetCommState Error","Error",MB_OK+MB_ICONERROR);
// CloseHandle(hComm);
}
//Set LPT1 conditions......
//.....
else
{
WriteFile(hComm, &bSign, 1, &dwBytesRecive,NULL);
}
CloseHandle(hComm);
}

[kurul1]

Je vais regarder cela, merci de ta réponse

[kurul1]

ton code met le message d'erreur du GetCommState.

En cherchant, j'ai trouver la dll inpout32.dll pour piloter le port parallèle, mais j'ai des soucis.

Je dois synchroniser deux logiciels présent sur deux PC.
sur le premier PC, j'ai un logiciel qui envois un front montant sur la broche D0 du port parallèle.

Je voudrais sur le deuxième PC, me mettre en attente du front montant sur D0, et de déclancher un affichage lorsque l'on reçoit le front montant.

J'ai donc importer les fonctions de lecture écriture de la DLL comme ceci

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
 
#include <conio.h>
 
/* prototype (function typedef) for DLL function Inp32 et out32: */
typedef short _stdcall (*PtrIn)(short portaddr);
typedef void _stdcall (*PtrOut)(short EndPorta, short valor);
 
// Adresse du port
unsigned short AdressePort = 0x378;
 
// Instance de la librairie
HINSTANCE hLib;
 
// Fonction de lecture
PtrIn Lecture;
 
// Fonction d'écriture
PtrOut Ecriture;
 
 
// On charge la librairie
hLib = LoadLibrary("inpout32.dll");
 
// Si le chargement s'est mal passé
if(hLib == NULL)
{
	ShowMessage("Erreur de chargement de la librairie !");
	return false;
}
 
// On récupère la fonction de lecture
Lecture = (PtrIn) GetProcAddress(hLib, "Inp32");
 
// Si le chargement s'est mal passé
if(Lecture == NULL)
{
	ShowMessage("Erreur de chargement de la fonction inp32 !");
	return false;
}
 
// On récupère la fonction d'écriture
Ecriture = (PtrOut) GetProcAddress(hLib, "Out32");
 
// Si le chargement s'est mal passé
if(Ecriture == NULL)
{
	ShowMessage("Erreur de chargement de la fonction out32 !");
	return false;
}

J'utilise également une union pour pouvoir récupérer les valeurs de chaque broche (ce que je faisait avec dlPortIO)

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
 
// Union pour la récupération des broches de données
union TBrochesDonnees
{
	char chr;
	struct
	{
		unsigned char D0 : 1;
		unsigned char D1 : 1;
		unsigned char D2 : 1;
		unsigned char D3 : 1;
		unsigned char D4 : 1;
		unsigned char D5 : 1;
		unsigned char D6 : 1;
		unsigned char D7 : 1;
	};
};

Et donc pour lire les données du Port, je fais ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
// Union pour récupérer les données
TBrochesDonnees Donnees;
 
// On récupère les données
Donnees.chr = (Lecture)(AdressePort);

Bien sur, j'ai une boucle pour l'attente du front montant, mais je ne l'ai pas détaillé ici

Mon souci, c'est que les valeurs des broches restent toujours à 0 dans mon programme, il n'y a pas de changement d'état sur le 2ème PC.

J'ai tester si le voltage sur les broches changeait et c'est le cas.

J'ai donc fait un deuxième test en exécutant les 2 logiciels sur le même PC, et là, le changement d'état se produit.

De quoi cela peut-il venir

Merci d'avance pour votre aide

[Gouyon]

Question bête mais est ce que tes deux machines tournent sous le même système d'exploitation? Ça peut être une source de problème.

Es tu obligé d'utiliser lpt1 car cette synchronisation peut aussi se faire via le réseau Ethernet ou plus simplement avec une liaison série par l'envoi d'un message. A moins que tu n'aies des contraintes temps réel.

[kurul1]

Oui, mes deux machines tournent sur windows XP.

J'ai effectivement des contraintes qui m'oblige a utiliser le port parallèle, car c'est un logiciel qui envois un front montant sur le port parallèle que je n'ai pas développé. Moi je suis chargé uniquement de réceptionner les données sur le port et de détecter un front montant.

Le logiciel qui envoit le front montant est un logiciel qui pilote une plateforme de force. Et je doit synchroniser cela avec mon soft pour que dès que l'on déclenche une acquisition sur la plateforme, j'ai un affichage qui se réalise.

J'ai déjà réalisé cette synchronisation avec le composant DlPortIO qui était très pratique mais qui malheureusement ne fonctionne plus avec BDS2006, d'où ma recherche d'une autre solution

[Gouyon]

As tu vérifié en bout de ligne que le voltage est bon. J'ai déjà fait ce genre de manip il y a très longtemps (avec une machine sous dos) et au bout de quelques mètres de ligne le signal TTL n'était plus bon. Du coup pour résoudre le problème j'ai mis un dispositif entre les deux pour regonfler mon signal.

Sinon il existe des cartes chez national instrument par exemple qui sont capable de gérer ton problème. Maintenant c'est peut être pas possible pour des raisons de budget.

As tu essayé d'inverser les rôles de tes PC?
As tu vérifié le branchement de ton cable entre les deux PC?
Es ce toi qui a réalisé le cable de liaison?
As tu une masse commune aux deux PC?

Tu as peut être déjà regardé toutes ces questions mais c'est des éléments à vérifier avant de se dire qu'il y a un problème au niveau du code. J'en sais quelque chose.

[kurul1]

As tu vérifié en bout de ligne que le voltage est bon.

Oui je l'ai vérifié et le changement d'état à bien lieu.

As tu essayé d'inverser les rôles de tes PC?

Oui et le résultat est le même.

As tu vérifié le branchement de ton cable entre les deux PC?

Oui plusieurs fois

Es ce toi qui a réalisé le cable de liaison?

C'est mon collègue électronicien qui à réalisé le cable et c'est avec lui que j'ai fait les test pour les voltages.

As tu une masse commune aux deux PC?

Non puisque nous utilisons deux PC portable.
On as même essayer avec un PC classique et le résultat est le même.

Si tu veux, avant que je passe sour BDS2006, tout fonctionnait parfaitement avec le composant DLPortIO, mais maintenant plus rien.


Ca me gène donc fortement car j'ai a développer plusieurs logiciels utilisant ce type de synchronisation.

[Gouyon]

Ce qui me surprend le plus c'est quand tu fais tourner tes deux programme sur la même machine ça marche?

A priori ça veut dire que les registres sont bien lu.

Peux tu essayer avec une alim de mettre un front montant sur la broche que tu teste et voir si tu lis quelque chose?

Encore une question tu envois un signal de type impulsion ou ton signal reste à un.Dans le premier cas il se peut que l'impulsion soit trop courte.

Sinon essaye de récupérer ton ancien composant (DLPortIO) et intègre le dans la bibliothèque de composants. Essaye aussi de voir si tu peut récupérer le source de DLPortIO et recompile le sous Xp. J'ai eu un cas comme ça avec une DLL qui fonctionnait très bien sous 2000 et qui ne fonctionnait plus sous Xp pour d'obsures raison de sécurités. Après recompilation de la dll l'application a fonctionner sous xp et sous 2000 (avec la dll recompilée)


Regarde aussi dans les forums windows (je pense au SDK) Il est possible qu'il y ai une dll ou une instruction qui convienne.
Vas voir http://www.aurel32.net/elec/port_parallele.php Il y a pas mal d'info

[kurul1]

Ce n'est pas une impulsion que le logiciel envois.
Il passe D0 à 1 au début de l'acquisition et repasse à 0 quand l'acquisition est terminée.

Pour DLPortIo, le problème n'est pas de l'ajouter dans la bibliothèque de composant, il s'ajoute, mais c'est à la compilation de mon soft que j'ai une erreur externe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[Lieur Erreur] Error: Externe '__fastcall Classes::RegisterComponents(const System::AnsiString, System::TMetaClass * const *, const int)' non résolu référencé par C:\PROGRAM FILES\BORLAND\BDS\4.0\LIB\DLPRINTER.LIB|C:\prg\CBuilder6\CBuilder6\DlIoPOrt\DLPrinterPortIO.cpp

Il cherche un chemin qui n'existe pas puisque c'est le chemin pour Builder 6 et je ne sais pas ou il faut changer ca. J'ai parcourut toutes les options du projet permettant d'ajouter le composant, sans résultats.

[Gouyon]

Je n'ai pas l'habitude de cette erreur sous CBuilder mais pose la question sur un autre post. Effectivement je suis persuadé qu'il s'agit d'un chemin qui n'est pas trouvé par l'éditeur de lien ou bien il manque un fichier quelque part.

Combien de temps dure une acquisition?

[kurul1]

c'est déjà fait, j'en ai un post de 3 pages et pas de solution.

ici

Du coup j'ai créé un autre post pour trouver une solution autre et voilà ou j'en suis.

Sinon la durée d'une acquisition peut être variable, c'est selon les besoins, mais jamais moins de 5 secondes ca c'est sur

[Gouyon]

5 secondes c'est long donc ce n'est pas un problème lié à une durée d'impulsion trop courte.

[kurul1]

Non justement, j'y avais pensez mais c'est pas le cas, puisque le logiciel reste à l'état 1 tout le long d'une acquisition et redescend à 0 la fin de l'acquisition.

Et 5 secondes c'est le minimum possible, en règle générale, les acquisitions dure entre 20 et 40 secondes pour les applications que l'on en fait.

Je trouve aucune solution pour résoudre ca et ca commence à m'inquiété, car on a absolument besoin de cette synchronisation pour que les données qu'on récoltes soit correcte.

[blondelle]

Salut
une idee comme cela est ce que ton port est bien configure en entree, le port parallele etant bidirectionnel, c'est peut etre la que se situe ton probleme

[kurul1]

J'ai regarder cela aussi.

Quand j'utilisais DLPortIo il fallait mettre le bit 5 du registre de control à 1, c'est à dire le bit 5 du registre de base + 2, soit la broche IO

j'ai donc essayé avec la DLL en faisant ceci.

Je me suis fait une classe pour le Port parallèle

PortParallele.h

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
 
#include <vcl.h>
#include <conio.h>
 
/* prototype (function typedef) for DLL function Inp32 et out32: */
typedef short _stdcall (*PtrIn)(short portaddr);
typedef void _stdcall (*PtrOut)(short EndPorta, short valor);
 
// Union pour la récupération des broches de données
union TBrochesDonnees
{
	char chr;
	struct
	{
		unsigned char D0 : 1;
		unsigned char D1 : 1;
		unsigned char D2 : 1;
		unsigned char D3 : 1;
		unsigned char D4 : 1;
		unsigned char D5 : 1;
		unsigned char D6 : 1;
		unsigned char D7 : 1;
	};
};
 
// Union pour la récupération des broches d'état
union TBrochesEtats
{
	char chr;
	struct
	{
		unsigned char B0 : 1;
		unsigned char B1 : 1;
		unsigned char B2 : 1;
		unsigned char ERREUR : 1;
		unsigned char SELECT : 1;
		unsigned char PE : 1;
		unsigned char ACK : 1;
		unsigned char BUSY : 1;
	};
};
 
// Union pour la récupération des broches de controles
union TBrochesControles
{
	char chr;
	struct
	{
		unsigned char STROBE : 1;
		unsigned char AUTOFEED : 1;
		unsigned char INIT : 1;
		unsigned char SELECT_IN : 1;
		unsigned char AI : 1;
		unsigned char IO : 1;
		unsigned char Bit6 : 1;
		unsigned char Bit7 : 1;
	};
};
 
// Classe pour le port parallèle
class TPortParallele
{
	private :
 
		// Adresse du port
		unsigned short AdressePort;
 
		// Instance de la librairie
		HINSTANCE hLib;
 
		// Fonction de lecture
		PtrIn Lecture;
 
 
		// Fonction d'écriture
 
		PtrOut Ecriture;
 
		// Booléen pour marquer que le port est en lecture
		bool EnLecture;		
 
	public :
 
		// Constructeur
		__fastcall TPortParallele();
 
		// Destructeur
		__fastcall ~TPortParallele();
 
		// Méthode chargée de l'initialisation
		bool __fastcall Initialisation(unsigned short Adresse);
 
		// Méthode chargée de mettre le Port à 0
		void __fastcall MiseAZero(void);
 
		// Méthode chargée de mettre le port en lecture
		void __fastcall MiseEnLecture(void);
 
		// Méthode chargée de mettre le port en écriture
		void __fastcall MiseEnEcriture(void);
 
		// Lecture des données
		TBrochesDonnees __fastcall LireDonnees(void);
 
		// Lecture des Etats
		TBrochesEtats __fastcall LireEtats(void);
 
		// Lecture des controles
		TBrochesControles __fastcall LireControles(void);
 
 
		// Méthode chargée d'afficher l'état des controles
		void __fastcall AfficherControles(TBrochesControles Controles);
};

PortParallele.cpp

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
 
#include "PortParallele.h"
 
//---------------------------------------------------------------------------
 
// Constructeur
__fastcall TPortParallele::TPortParallele()
{
	// On marque que le port n'est pas en lecture
	EnLecture = false;	
}
 
//---------------------------------------------------------------------------
 
// Destructeur
__fastcall TPortParallele::~TPortParallele()
{
	// On libère la librairie
	FreeLibrary(hLib);
}
 
//---------------------------------------------------------------------------
 
// Méthode chargée de l'initialisation
bool __fastcall TPortParallele::Initialisation(unsigned short Adresse)
{
	// Booléen pour la valeur de retour
	bool Retour;
 
	// On affecte l'adresse du port
	AdressePort = Adresse;
 
	// On charge la librairie
	hLib = LoadLibrary("inpout32.dll");
 
	// Si le chargement s'est mal passé
	if(hLib == NULL)
	{
		ShowMessage("Erreur de chargement de la librairie !");
 
		return false;
	}
 
	// On récupère la fonction de lecture
	Lecture = (PtrIn) GetProcAddress(hLib, "Inp32");
 
	// Si le chargement s'est mal passé
	if(Lecture == NULL)
	{
		ShowMessage("Erreur de chargement de la fonction inp32 !");
 
		return false;
	}
 
 
	// On récupère la fonction d'écriture
	Ecriture = (PtrOut) GetProcAddress(hLib, "Out32");
 
	// Si le chargement s'est mal passé
	if(Ecriture == NULL)
	{
		ShowMessage("Erreur de chargement de la fonction out32 !");
 
		return false;
	}
 
	// SI l'on est ici, c'est que les chargements se sont bien passé
	// On met le port à 0
	MiseAZero();
 
	// On retourne true pour marquer que l'initialisation s'est bien passé
	return true;
}
 
//---------------------------------------------------------------------------
 
// Méthode chargée de mettre le Port à 0
void __fastcall TPortParallele::MiseAZero(void)
{
	// Si le port n'est pas déjà en écriture
	if(EnLecture)
	{
		// On se met en écriture
		MiseEnEcriture();
	}
 
	// On met les broches de données à 0
	(Ecriture)(AdressePort + 2, 0x00);
}
 
//---------------------------------------------------------------------------
 
// Méthode chargée de mettre le port en lecture
void __fastcall TPortParallele::MiseEnLecture(void)
{
	// On lit les broches de controles
	TBrochesControles Controles = LireControles();
 
	// On met la broche IO à 1
	Controles.IO = 1;
 
	// On écrit la nouvelle valeur des ports
	(Ecriture)(AdressePort + 2, Controles.chr);
 
	// On le met en lecture
	EnLecture = true;
}
 
//---------------------------------------------------------------------------
 
// Méthode chargée de mettre le port en écriture
void __fastcall TPortParallele::MiseEnEcriture(void)
{
	// On lit les broches de controles
	TBrochesControles Controles = LireControles();
 
	// On met la broche IO des controles à 0
	(Ecriture)(AdressePort + 2, Controles.chr & 0xDF);
 
	// On le met en écriture
	EnLecture = false;
}
 
//---------------------------------------------------------------------------
 
// Lecture des données
TBrochesDonnees __fastcall TPortParallele::LireDonnees(void)
{
	// Union pour récupérer les données
	TBrochesDonnees Donnees;
 
	// Si le port n'est pas déjà en lecture
	if(!EnLecture)
	{
		// On se met en lecture
		MiseEnLecture();
	}
 
	// On récupère les données
	Donnees.chr = (Lecture)(AdressePort);
 
	// On les retournes
	return Donnees;
}
 
//---------------------------------------------------------------------------
 
// Lecture des Etats
TBrochesEtats __fastcall TPortParallele::LireEtats(void)
{
	// Union pour récupérer les données
	TBrochesEtats Etats;
 
	// On récupère les Etats
	Etats.chr = (Lecture)(AdressePort + 1);
 
	// On les retournes
	return Etats;
}
 
//---------------------------------------------------------------------------
 
// Lecture des controles
TBrochesControles __fastcall TPortParallele::LireControles(void)
{
	// Union pour récupérer les données
	TBrochesControles Controles;
 
	// On récupère les controles
	Controles.chr = (Lecture)(AdressePort + 2);
 
	// On les retournes
	return Controles;
}
 
//---------------------------------------------------------------------------

Et donc voilà ce que je fait lorsque je veux lire sur le port
j'ai fait un programme avec des Edit qui affiche les valeurs de chaque broche

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
 
#include "PortParallele.h"
......
 
// OBjet pour piloter le port Parallele
TPortParallele *Port;
 
// Objet pour récupérer les données
TBrochesDonnees Donnees;
 
// OBject pour récupérer les Etats
TBrochesEtats Etats;
 
// OBject pour récupérer les controles
TBrochesControles Controles;
 
// Booléen pour savoir si l'on est en lecture ou non
bool Lecture;
 
 
// On ouvre le port
Port = new TPortParallele();
 
// Si l'initialisation s'est bien passé
if(Port->Initialisation(0x378))
{
	// On marque que l'on est en lecture
	Lecture = true;
 
	// Tant que l'on est en lecture
	while(Lecture)
	{
		// On lit les données sur le port parallèle
		Donnees = Port->LireDonnees();
 
		// On renseigne les Edit
		EditValeurDonnees->Text = AnsiString(int(Donnees.chr));
 
		EditD0->Text = AnsiString(Donnees.D0);
		EditD1->Text = AnsiString(Donnees.D1);
		EditD2->Text = AnsiString(Donnees.D2);
		EditD3->Text = AnsiString(Donnees.D3);
		EditD4->Text = AnsiString(Donnees.D4);
		EditD5->Text = AnsiString(Donnees.D5);
		EditD6->Text = AnsiString(Donnees.D6);
		EditD7->Text = AnsiString(Donnees.D7);
 
 
		// On lit les états sur le Port
		Etats = Port->LireEtats();
 
		// On renseigne les Edit
		EditValeurEtats->Text = AnsiString(int(Etats.chr));
		EditError->Text = AnsiString(Etats.ERREUR);
		EditSelect->Text = AnsiString(Etats.SELECT);
		EditPe->Text = AnsiString(Etats.PE);
		EditAck->Text = AnsiString(Etats.ACK);
		EditBusy->Text = AnsiString(Etats.BUSY);
 
 
		// On lit les controles sur le port
		Controles = Port->LireControles();
 
		// On renseigne les Edit
		EditValeurControles->Text = AnsiString(int(Controles.chr));
 
		EditStrobe->Text = AnsiString(Controles.STROBE);
		EditAutoFeed->Text = AnsiString(Controles.AUTOFEED);
		EditInit->Text = AnsiString(Controles.INIT);
		EditSelectIn->Text = AnsiString(Controles.SELECT_IN);
		EditAI->Text = AnsiString(Controles.AI);
		EditIO->Text = AnsiString(Controles.IO);
 
		Application->ProcessMessages();
	}
}

Et là, ca fait n'importe quoi. J'ai une valeur globale pour les données qui vaut -1.

Si je ne fait pas la mise en lecture, tout reste à 0

[Gouyon]

Je me suis un peu baladé sur internet et j'ai trouvé un DLPortIO. J'ai téléchargé et il y avait 2 applications une en C et une en visual basic. Je te suggère déjà de voir en mettant la pin D0 à 1 (avec un géné de tension par exemple) et toutes les autres à zéro (en les reliant à la pin GND) de voir si avec ces applications tu lis bien le bon résultat.

Maintenant j'ai essayé d'utiliser cette dll avec CBuilder et j'ai une erreur au niveau de l'édition de lien. Et quand je regarde les .h de la dll c'est du visual studio tout craché ce qui peut poser problème avec le CBuilder.

Il y a une manip possible (mais lourdingue) qui consiste à écrire une DLL avec visual studio (il y a une version express gratuite téléchargeable chez microsoft) qui soit compatible avec CBuilder. C'est très chiant mais ça m'a sauvé la vie une fois.

[kurul1]

Pour visual C++ ce n'est pas un souci, on l'a également.

Désolé, j'ai modifié mon post précédent pendant que tu postais, j'ai mis tout le code que j'utilise actuellement pour que tu puisse voir ce que je fait.

Pour DlPortIO, il y a une version pour C++Builder que j'ai, tu peux d'ailleurs trouver un tuto sur DVP pour l'utiliser, mais cela me produit depuis que je suis passez à BDS2006 l'erreur que je t'ai exposé plus haut

[Gouyon]

J'ai pensé à quelque chose d'autre. Est ce qu'il y a une imprimante affecté au port parallèle. Si c'est le cas le système peut bloquer l'accès.

[kurul1]

non aucune imprimante n'est affecter car toutes nos imprimantes sont en réseau

De plus pour les portables, ils ne sont connecter ni à internet ni à une imprimante.